@raclettejs/core 0.1.11 → 0.1.13

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

@@ -6,7 +6,11 @@ export default (fastify: PluginFastifyInstance) => {
 
   const handler = async (req: FastifyRequest, reply: FastifyReply) => {
     try {
-      const payload = await tagService.readTags(fastify, req.requestParams)
+      const payload = await tagService.readTags(
+        fastify,
+        req.requestParams,
+        req.query,
+      )
 
       if (!payload || payload.length === 0) {
         return reply.code(204).send()
@@ -24,7 +28,7 @@ export default (fastify: PluginFastifyInstance) => {
     handler,
     onRequest: [fastify.authenticate],
     config: {
-      type: "dataPush",
+      type: "dataRead",
     },
     schema: {
       summary: "Get all tags for the given project.",

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

@@ -101,6 +101,27 @@ export class TagService {
     return createTagPayload(fastify, [tag], requestData)
   }
 
+  /**
+   * Core function to read a tag by name – used for internal system functions mainly
+   */
+  async _readTagByTitle(
+    fastify: PluginFastifyInstance,
+    title: string,
+  ): Promise<TagType> {
+    try {
+      const tags = await this.tagModel.find({ title }).lean()
+
+      if (!tags) {
+        throw new Error(`Tag with title ${title} not found`)
+      }
+
+      return tags[0]
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
   /**
    * Core function to read tags by ID or filter parameters (returns raw data)
    */
@@ -153,7 +174,7 @@ export class TagService {
 
         return createTagPayload(fastify, [tag], requestData)
       } else {
-        const tags = await this._readTags(fastify, filter)
+        const tags = await this._readTags(fastify, filter, requestData.options)
 
         return createTagPayload(fastify, tags, requestData)
       }

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

@@ -39,7 +39,7 @@ export default (fastify: PluginFastifyInstance) => {
     handler,
     onRequest: [fastify.authenticate],
     config: {
-      type: "dataPush",
+      type: "dataRead",
     },
     schema: {
       summary: "Get user",

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

@@ -39,7 +39,7 @@ export default (fastify: PluginFastifyInstance) => {
     handler,
     onRequest: [fastify.authenticate],
     config: {
-      type: "dataPush",
+      type: "dataRead",
     },
     schema: {
       summary: "Get users",

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

@@ -19,6 +19,9 @@ export default (fastify: PluginFastifyInstance) => {
     reply: FastifyReply,
   ) => {
     try {
+      if (!req.user.isAdmin) {
+        throw new ForbiddenError("Only Admins can use this feature")
+      }
       if (req.user._id === req.params._id) {
         throw new ForbiddenError("A user cannot remove itself")
       }

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

@@ -168,9 +168,8 @@ export class UserService {
     fastify: PluginFastifyInstance,
     requestData: FrontendPayloadRequestData,
     filter: Record<string, any> = {},
-    options: QueryOptions = {},
   ): Promise<FrontendPayload<PublicUser[]>> {
-    const users = await this._readUsers(fastify, filter, options)
+    const users = await this._readUsers(fastify, filter, requestData.options)
 
     return createUserPayload(fastify, users, requestData)
   }

package/services/backend/src/corePlugins/raclette__core/frontend/generated-config.ts

@@ -15,12 +15,12 @@ export default {
         getAll: {
           target: "/raclette__core/account/all",
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         get: {
           target: (payload) => `/raclette__core/account/${payload._id}`,
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         update: {
           target: (payload) => `/raclette__core/account/${payload._id}`,
@@ -83,12 +83,12 @@ export default {
         getAll: {
           target: "/raclette__core/interactionLink/all",
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         get: {
           target: (payload) => `/raclette__core/interactionLink/${payload._id}`,
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         update: {
           target: (payload) => `/raclette__core/interactionLink/${payload._id}`,
@@ -146,12 +146,12 @@ export default {
         getAll: {
           target: "/raclette__core/project/all",
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         get: {
           target: (payload) => `/raclette__core/project/${payload._id}`,
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         create: {
           target: "/raclette__core/project",
@@ -209,12 +209,12 @@ export default {
         getAll: {
           target: "/raclette__core/tag/all",
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         get: {
           target: (payload) => `/raclette__core/tag/${payload._id}`,
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         update: {
           target: (payload) => `/raclette__core/tag/${payload._id}`,
@@ -272,12 +272,12 @@ export default {
         getAll: {
           target: "/raclette__core/user/all",
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         get: {
           target: (payload) => `/raclette__core/user/${payload._id}`,
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         update: {
           target: (payload) => `/raclette__core/user/${payload._id}`,
@@ -335,12 +335,12 @@ export default {
         getAll: {
           target: "/raclette__core/composition/all",
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         get: {
           target: (payload) => `/raclette__core/composition/${payload._id}`,
           method: "get",
-          storeActionType: "dataPush"
+          storeActionType: "dataRead"
         },
         update: {
           target: (payload) => `/raclette__core/composition/${payload._id}`,

package/services/backend/src/domains/index.ts

@@ -6,6 +6,9 @@ import registerSystem from "./system"
  * Core service export all routes
  */
 const registerCore = async (fastify: FastifyInstance) => {
+  if (!fastify.core) {
+    fastify.core = {}
+  }
   registerSystem(fastify)
 }
 

package/services/backend/src/domains/system/collections.service.ts

@@ -0,0 +1,119 @@
+import type { PluginFastifyInstance } from "types"
+import mongoose, { type Connection } from "mongoose"
+
+export interface CollectionInfo {
+  name: string
+  count: number
+  size: number
+  indexes: number
+}
+
+export class CollectionService {
+  private connection: Connection
+
+  constructor(connection: Connection) {
+    this.connection = connection
+  }
+
+  /**
+   * Get all collection names and their metadata
+   */
+  async getCollections(
+    fastify: PluginFastifyInstance,
+  ): Promise<CollectionInfo[]> {
+    try {
+      const db = this.connection.db
+      const collections = await db.listCollections().toArray()
+
+      const collectionInfos: CollectionInfo[] = []
+
+      for (const collection of collections) {
+        const collectionName = collection.name
+
+        // Get document count
+        const count = await db.collection(collectionName).countDocuments()
+
+        // Get collection stats using MongoDB command
+        const stats = await db.command({ collStats: collectionName })
+
+        collectionInfos.push({
+          name: collectionName,
+          count: count || 0,
+          size: stats.size || 0,
+          indexes: stats.nindexes || 0,
+        })
+      }
+
+      fastify.log.info(`[API] Retrieved ${collectionInfos.length} collections`)
+
+      return collectionInfos
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Drop specific collections
+   */
+  async dropCollections(
+    fastify: PluginFastifyInstance,
+    collectionNames: string[],
+  ): Promise<{ dropped: string[]; failed: string[] }> {
+    try {
+      const db = this.connection.db
+      const dropped: string[] = []
+      const failed: string[] = []
+
+      for (const collectionName of collectionNames) {
+        try {
+          // Check if collection exists
+          const collections = await db
+            .listCollections({ name: collectionName })
+            .toArray()
+
+          if (collections.length === 0) {
+            fastify.log.warn(`Collection ${collectionName} does not exist`)
+            failed.push(collectionName)
+            continue
+          }
+
+          // Drop the collection
+          await db.collection(collectionName).drop()
+          dropped.push(collectionName)
+          fastify.log.info(`[API] Dropped collection: ${collectionName}`)
+        } catch (error: any) {
+          fastify.log.error(
+            `Failed to drop collection ${collectionName}: ${error.message}`,
+          )
+          failed.push(collectionName)
+        }
+      }
+
+      return { dropped, failed }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Drop all collections (use with extreme caution!)
+   */
+  async dropAllCollections(
+    fastify: PluginFastifyInstance,
+  ): Promise<{ dropped: string[]; failed: string[] }> {
+    try {
+      const collections = await this.getCollections(fastify)
+      const collectionNames = collections.map((c) => c.name)
+
+      return await this.dropCollections(fastify, collectionNames)
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+}
+
+export const createCollectionService = (connection: Connection) =>
+  new CollectionService(connection)

package/services/backend/src/domains/system/index.ts

@@ -1,8 +1,16 @@
 import type { FastifyInstance } from "fastify"
+import mongoose from "mongoose"
 import registerRoutes from "./routes"
+import { createCollectionService } from "./collections.service"
 
 const registerSystem = (fastify: FastifyInstance) => {
   registerRoutes(fastify)
+
+  // create and pass in the model to your service
+  const collectionService = createCollectionService(mongoose.connection)
+
+  // decorate the service to the instance, so we can easily call it everywhere
+  fastify.core.collectionService = collectionService
 }
 
 export default registerSystem

package/services/backend/src/domains/system/routes/index.ts

@@ -7,6 +7,8 @@ import {
 import deploy from "./route.deploy"
 import login from "./route.user.login"
 import checkToken from "./route.user.checkToken"
+import getAllCollections from "./route.collection.getAll"
+import deleteCollections from "./route.collection.remove"
 
 const registerRoutes = async (fastify: FastifyInstance) => {
   await fastify.get("/system/deploy", deploy(fastify))
@@ -17,5 +19,8 @@ const registerRoutes = async (fastify: FastifyInstance) => {
   await fastify.get("/admin/cache/blocks", getBlockedLogins(fastify))
   await fastify.delete("/admin/cache/blocks/:key", resetLoginBlock(fastify))
   await fastify.delete("/admin/cache/blocks", resetAllLoginBlocks(fastify))
+
+  await fastify.get("/admin/collections/all", getAllCollections(fastify))
+  await fastify.delete("/admin/collections", deleteCollections(fastify))
 }
 export default registerRoutes

package/services/backend/src/domains/system/routes/route.collection.getAll.ts

@@ -0,0 +1,61 @@
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { PluginFastifyInstance } from "types"
+import { ForbiddenError } from "@/utils/errors"
+
+export default (fastify: PluginFastifyInstance) => {
+  const collectionService = fastify.core.collectionService
+
+  const handler = async (req: FastifyRequest, reply: FastifyReply) => {
+    try {
+      // Restrict to admin users only
+      if (!req.user.isAdmin) {
+        throw new ForbiddenError(
+          "Only Admins can access collection information",
+        )
+      }
+
+      const collections = await collectionService.getCollections(fastify)
+
+      return {
+        success: true,
+        data: collections,
+        total: collections.length,
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    schema: {
+      summary: "Get all collections",
+      description:
+        "Retrieve all MongoDB collections with metadata (admin only, debug feature)",
+      tags: ["debug/collections"],
+      response: {
+        200: {
+          type: "object",
+          properties: {
+            success: { type: "boolean" },
+            data: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                  count: { type: "number" },
+                  size: { type: "number" },
+                  indexes: { type: "number" },
+                },
+              },
+            },
+            total: { type: "number" },
+          },
+        },
+      },
+    },
+  }
+}

package/services/backend/src/domains/system/routes/route.collection.remove.ts

@@ -0,0 +1,93 @@
+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 BodySchema = Type.Object({
+  collections: Type.Array(Type.String(), {
+    description: "Array of collection names to drop",
+    minItems: 1,
+  }),
+  dropAll: Type.Optional(
+    Type.Boolean({
+      description:
+        "If true, drops all collections (overrides collections array)",
+    }),
+  ),
+})
+type Body = Static<typeof BodySchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const collectionService = fastify.core.collectionService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Body: Body
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      // Restrict to admin users only
+      if (!req.user.isAdmin) {
+        throw new ForbiddenError("Only Admins can drop collections")
+      }
+
+      let result
+
+      if (req.body.dropAll) {
+        fastify.log.warn(
+          `[API] Admin ${req.user._id} is dropping ALL collections`,
+        )
+        result = await collectionService.dropAllCollections(fastify)
+      } else {
+        fastify.log.warn(
+          `[API] Admin ${req.user._id} is dropping collections: ${req.body.collections.join(", ")}`,
+        )
+        result = await collectionService.dropCollections(
+          fastify,
+          req.body.collections,
+        )
+      }
+
+      return {
+        success: true,
+        dropped: result.dropped,
+        failed: result.failed,
+        message: `Successfully dropped ${result.dropped.length} collection(s)`,
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    schema: {
+      summary: "Drop collections",
+      description:
+        "Drop selected MongoDB collections (admin only, debug feature - USE WITH CAUTION)",
+      tags: ["debug/collections"],
+      body: BodySchema,
+      response: {
+        200: {
+          type: "object",
+          properties: {
+            success: { type: "boolean" },
+            dropped: {
+              type: "array",
+              items: { type: "string" },
+            },
+            failed: {
+              type: "array",
+              items: { type: "string" },
+            },
+            message: { type: "string" },
+          },
+        },
+      },
+    },
+  }
+}

package/services/backend/src/types/custom-fastify.d.ts

@@ -25,6 +25,7 @@ declare module "fastify" {
     uos: Client
     http: HttpService
     taskManager: TaskManager
+    core: any
   }
 
   interface FastifyRequest {

package/services/backend/src/utils/request.utils.ts

@@ -11,7 +11,7 @@ export const createRequestParams = (
   req: RequestWithCommonHeaders,
   config: FastifyContextConfig,
 ): FrontendPayloadRequestData => {
-  return {
+  const requestParams = {
     appSessionId: req.headers["app-session-id"] ?? "",
     appRequestCode: req.headers["app-request-code"] ?? "",
     requestId: req.id ?? "",
@@ -19,6 +19,33 @@ export const createRequestParams = (
     broadcast: req.headers["app-broadcast-channels"] ?? false,
     project: req.headers["current-project"] ?? "",
     userId: req.user?.id,
+    options: {},
     ...config,
   }
+  // put global query modifiers into requestParams and remove them from params
+  if (req?.query?.limit) {
+    requestParams.options.limit = req.query.limit
+    delete req.query.limit
+  }
+  if (req?.query?.offset) {
+    requestParams.options.offset = req.query.offset
+    delete req.query.offset
+  }
+  if (req?.query?.search) {
+    requestParams.options.search = req.query.search
+    delete req.query.search
+  }
+  if (req?.body?.limit) {
+    requestParams.options.limit = req.body.limit
+    delete req.body.limit
+  }
+  if (req?.body?.offset) {
+    requestParams.options.offset = req.body.offset
+    delete req.body.offset
+  }
+  if (req?.body?.search) {
+    requestParams.options.search = req.body.search
+    delete req.body.search
+  }
+  return requestParams
 }

package/services/backend/yarn.lock

@@ -345,7 +345,7 @@
   resolved "https://registry.yarnpkg.com/@lukeed/ms/-/ms-2.0.2.tgz#07f09e59a74c52f4d88c6db5c1054e819538e2a8"
   integrity sha512-9I2Zn6+NJLfaGoz9jN3lpwDgAYvfGeNYdbAIjJOqzs4Tpc+VU3Jqq4IofSUBKajiDS8k9fZIg18/z13mpk1bsA==
 
-"@mongodb-js/saslprep@^1.1.9":
+"@mongodb-js/saslprep@^1.1.9", "@mongodb-js/saslprep@^1.3.0":
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/@mongodb-js/saslprep/-/saslprep-1.3.0.tgz#75bb770b4b0908047b6c6ac2ec841047660e1c82"
   integrity sha512-zlayKCsIjYb7/IdfqxorK5+xUMyi4vOKcFy10wKJYc63NSdKI8mNME+uJqfatkPmOSMMUiojrL58IePKBm3gvQ==
@@ -2431,7 +2431,7 @@ mnemonist@^0.40.0:
   dependencies:
     obliterator "^2.0.4"
 
-mongodb-connection-string-url@^3.0.0:
+mongodb-connection-string-url@^3.0.0, mongodb-connection-string-url@^3.0.2:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/mongodb-connection-string-url/-/mongodb-connection-string-url-3.0.2.tgz#e223089dfa0a5fa9bf505f8aedcbc67b077b33e7"
   integrity sha512-rMO7CGo/9BFwyZABcKAWL8UJwH/Kc2x0g72uhDWzG48URRax5TCIcJ7Rc3RZqffZzO/Gwff/jyKwCU9TN8gehA==
@@ -2439,6 +2439,15 @@ mongodb-connection-string-url@^3.0.0:
     "@types/whatwg-url" "^11.0.2"
     whatwg-url "^14.1.0 || ^13.0.0"
 
+mongodb@^6.20.0:
+  version "6.20.0"
+  resolved "https://registry.yarnpkg.com/mongodb/-/mongodb-6.20.0.tgz#5212dcf512719385287aa4574265352eefb01d8e"
+  integrity sha512-Tl6MEIU3K4Rq3TSHd+sZQqRBoGlFsOgNrH5ltAcFBV62Re3Fd+FcaVf8uSEQFOJ51SDowDVttBTONMfoYWrWlQ==
+  dependencies:
+    "@mongodb-js/saslprep" "^1.3.0"
+    bson "^6.10.4"
+    mongodb-connection-string-url "^3.0.2"
+
 mongodb@~6.18.0:
   version "6.18.0"
   resolved "https://registry.yarnpkg.com/mongodb/-/mongodb-6.18.0.tgz#8fab8f841443080924f2cdaa22727cdb7eb20dc3"

package/services/frontend/package.json

@@ -18,6 +18,7 @@
   "dependencies": {
     "@date-io/date-fns": "3.2.1",
     "@mdi/font": "7.4.47",
+    "@sinclair/typebox": "0.34.41",
     "@tailwindcss/vite": "4.1.13",
     "@tsconfig/node20": "20.1.6",
     "@vueuse/core": "13.9.0",

package/services/frontend/src/core/constants/ApiClient.ts

@@ -8,4 +8,9 @@ export const cudOperationTypesList = [
   "dataDelete",
   "dataHardDeleted",
 ] as const
-export const readOperationTypesList = ["dataPush", "dataAdd", "dataSync"]
+export const readOperationTypesList = [
+  "dataReadModified",
+  "dataRead",
+  "dataAdd",
+  "dataSync",
+]

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

@@ -63,10 +63,17 @@ const $writeDataApi = (
       return resultData
     },
     // Method to complete the subjects when cleanup is needed
-    destroy: () => {
+    remove: () => {
       isLoadingSubject$.complete()
       dataSubject$.complete()
       errorSubject$.complete()
+      responseSubject$.complete()
+    },
+    clear: () => {
+      dataSubject$.next({})
+      errorSubject$.next({})
+      isLoadingSubject$.next(false)
+      dataSubject$.next({})
     },
   }