@raclettejs/core 0.1.10 → 0.1.12

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/composition/composition.schema.ts

@@ -36,6 +36,7 @@ const baseCompositionSchema = {
   tags: Type.Array(Type.String(), { default: [] }),
   icon: Type.Optional(Type.String()),
   pathname: Type.Record(Type.String(), Type.String(), { default: {} }),
+  slotLayout: Type.Optional(Type.String()),
   status: Type.Enum(
     { live: "live", test: "test", inProgress: "inProgress" },
     { default: "inProgress" },

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

@@ -4,9 +4,9 @@ import type {
   FrontendPayloadRequestData,
 } from "@c/payload/payloadTypes"
 import type { PluginFastifyInstance } from "types"
+import type { Model } from "mongoose"
 import { v4 as uuidv4, validate } from "uuid"
 import { createCompositionPayload } from "./helpers/payload"
-import { Model } from "mongoose"
 
 export type CompositionBody = Partial<Omit<CompositionType, "_id">> & {
   _id?: string

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

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

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

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

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/interactionLink/helpers/payload.ts

@@ -5,9 +5,13 @@ export const registerPayload = (fastify: PluginFastifyInstance) => {
   fastify.registerPayloadHandler<InteractionLink>("interactionLink", {
     type: "interactionLink",
     displayName: (interactionLink: InteractionLink) =>
-      interactionLink.description || "",
+      interactionLink.description ||
+      `CompositionType: ${interactionLink.slotType}` ||
+      "No Description",
     completion: (interactionLink: InteractionLink) =>
-      interactionLink.description || "",
+      interactionLink.description ||
+      interactionLink.slotType ||
+      "No Description",
     fields: (item: InteractionLink) => ({
       owner: item.author,
     }),

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { PluginFastifyInstance } from "types"
+import type { PluginFastifyInstance } from "types"
 import registerRoutes from "./routes"
 import { createModels } from "./tag.model"
 import { createTagService } from "./tag.service"
@@ -41,6 +41,7 @@ const registerTag = async (fastify: PluginFastifyInstance) => {
       operations: {
         readAll: tagService._readTags.bind(tagService),
         read: tagService._readTag.bind(tagService),
+        readByTitle: tagService._readTagByTitle.bind(tagService),
         create: tagService._createTag.bind(tagService),
         update: tagService._updateTag.bind(tagService),
         delete: tagService._removeTag.bind(tagService),

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

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

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 {