@raclettejs/core 0.1.34 → 0.1.36-canary.0

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@raclettejs/core",
-  "version": "0.1.34",
+  "version": "0.1.36-canary.0",
   "description": "racletteJS core package",
   "repository": "https://gitlab.com/raclettejs/core",
   "author": "Pacifico Digital Explorations GmbH <info@raclettejs.com>",
   "license": "AGPL-3.0-only",
   "type": "module",
   "scripts": {
-    ":install": "yarn install",
     ":install:services": "yarn --cwd ./services/backend install && yarn --cwd ./services/frontend install",
     "build": "node build.mjs || true",
     "dev": "node watch.mjs",
@@ -17,7 +16,6 @@
     "lint": "eslint",
     "lint:grouped": "FILTER_RULE=$RULE eslint . --ext .vue,.js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --format ./dev/eslint/groupByRuleFormatter.cjs",
     "lint:fix": "eslint --fix",
-    "prepare": "husky",
     "prepublishOnly": "yarn run build && yarn run sync",
     "publish:patch": "yarn version --patch && yarn publish",
     "sync": "node ./scripts/sync-exports.js"
@@ -30,6 +28,9 @@
   "types": "./types/index.ts",
   "files": [
     "services",
+    "!services/**/.yarn",
+    "!services/**/node_modules",
+    "!services/**/.yarnrc.yml",
     "bin",
     "dist",
     "types",
@@ -82,7 +83,7 @@
     "@emnapi/core": "1.9.2",
     "@emnapi/runtime": "1.9.2",
     "@eslint/js": "9.35.0",
-    "@raclettejs/types": "^0.1.34",
+    "@raclettejs/types": "workspace:",
     "@types/fs-extra": "11.0.4",
     "@types/js-yaml": "4.0.9",
     "@types/node": "25.5.0",
@@ -95,7 +96,6 @@
     "eslint-plugin-prettier": "5.5.5",
     "eslint-plugin-vue": "9.33.0",
     "globals": "17.4.0",
-    "husky": "9.1.7",
     "prettier": "3.8.1",
     "typescript": "5.9.3",
     "typescript-eslint": "8.59.2",

package/services/.dockerignore

@@ -4,3 +4,5 @@
 **/.git
 **/.gitignore
 **/docker-compose*
+**/.yarnrc.yml
+**/.yarn

package/services/backend/.dockerignore

@@ -9,4 +9,6 @@ package.json
 yarn.lock
 .prettierrc
 eslint.config.js
-dist
+dist
+.yarnrc.yml
+.yarn

package/services/backend/src/core/payload/payloadTypes.ts

@@ -48,4 +48,5 @@ export type BodyContent<T> = {
 
 export type FrontendPayload<T> = FrontendPayloadRequestData & {
   body: BodyContent<T>
+  workSessionId?: string
 }

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

@@ -1,5 +1,8 @@
 import type { FastifyInstance } from "fastify"
-import type { PluginOptions } from "../pluginTypes"
+import type {
+  PluginOptions,
+  RegisterForFrontendGenerationOptions,
+} from "../pluginTypes"
 import type {
   PluginRegistration,
   TrackedRoute,
@@ -137,17 +140,14 @@ class FrontendConfigRegistry {
 // Plugin Registration Functions (Called by Plugins)
 // ========================================
 
+export type {
+  RegisterForFrontendGenerationOptions,
+  RegisterForFrontendGenerationInput,
+} from "../pluginTypes"
+
 export const registerPluginForFrontendGeneration = (
   pluginOptions: PluginOptions,
-  options?: {
-    routePrefix?: string
-    entityMapping?: Record<string, string>
-    customConfig?: {
-      broadcast?: boolean
-      channels?: Record<string, string>
-      operationMapping?: Record<string, string>
-    }
-  },
+  options?: RegisterForFrontendGenerationOptions,
 ): void => {
   const registry = FrontendConfigRegistry.getInstance()
   registry.registerPlugin(pluginOptions, options)
@@ -306,7 +306,8 @@ const parseRouteInfo = (
     .filter((segment) => segment.startsWith(":"))
     .map((param) => param.substring(1))
 
-  const operationName = getOperationName(method, operationSegments)
+  const operationName =
+    route.config?.operationName ?? getOperationName(method, operationSegments)
 
   return {
     method,

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

@@ -8,7 +8,11 @@ import type {
   IntervalTaskOptions,
 } from "@/types"
 import type { CrudHandlers } from "@c/crud/crudTypes"
-import type { PluginFastifyInstance, PluginOptions } from "./pluginTypes"
+import type {
+  PluginFastifyInstance,
+  PluginOptions,
+  RegisterForFrontendGenerationInput,
+} from "./pluginTypes"
 import mongoose from "mongoose"
 import type EventEmitter from "@c/events/eventEmitter"
 import { type Listener } from "@c/events/eventEmitter"
@@ -204,8 +208,29 @@ export const createPluginFastifyInstance = (
       registerPluginContract(pluginOptions.key, contractData)
     },
 
-    registerForFrontendGeneration: (options: any) => {
-      registerPluginForFrontendGeneration(pluginOptions, options)
+    registerForFrontendGeneration: (
+      options?: RegisterForFrontendGenerationInput,
+    ) => {
+      const fg = pluginOptions._loaderInternal?.frontendGeneration
+      if (!fg) {
+        if (options === false) {
+          return
+        }
+        registerPluginForFrontendGeneration(
+          pluginOptions,
+          options === undefined ? {} : options,
+        )
+        return
+      }
+      if (options === false) {
+        fg.optedOut = true
+        return
+      }
+      fg.explicitCall = true
+      registerPluginForFrontendGeneration(
+        pluginOptions,
+        options === undefined ? {} : options,
+      )
     },
 
     cache: pluginCacheService,

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

@@ -5,6 +5,7 @@ import type { FastifyInstance } from "fastify"
 import fs from "fs"
 import path from "path"
 import { createPluginFastifyInstance } from "./pluginFastifyInstance"
+import { registerPluginForFrontendGeneration } from "@c/pluginSystem/configGenerator"
 import configService from "@c/config/configService"
 import { slugify } from "@shared/helper/pluginHelper"
 import { fileURLToPath } from "url"
@@ -759,6 +760,9 @@ const registerCollectedPlugins = async (
         routePrefix,
         absolutePath: plugin.pluginPath,
         frontendAbsolutePath: plugin.frontendPath,
+        _loaderInternal: {
+          frontendGeneration: { explicitCall: false, optedOut: false },
+        },
       }
 
       // Dynamically import the plugin module
@@ -786,10 +790,15 @@ const registerCollectedPlugins = async (
       const customFastify = createPluginFastifyInstance(fastify, pluginOptions)
 
       // Register the plugin, passing the restricted instance and options
-      await fastify.register(() => {
-        return pluginFunction(customFastify, pluginOptions)
+      await fastify.register(async () => {
+        await pluginFunction(customFastify, pluginOptions)
       })
 
+      const fg = pluginOptions._loaderInternal?.frontendGeneration
+      if (fg && !fg.optedOut && !fg.explicitCall) {
+        registerPluginForFrontendGeneration(pluginOptions, {})
+      }
+
       logPluginSuccess(
         fastify,
         plugin.type,

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

@@ -20,6 +20,18 @@ export enum PluginType {
   APP = "app",
 }
 
+/**
+ * Internal state the plugin loader attaches to `PluginOptions` while a backend
+ * plugin boots. Extend with additional nested sections as new loader features
+ * need post-plugin hooks.
+ */
+export type PluginLoaderInternalState = {
+  frontendGeneration: {
+    explicitCall: boolean
+    optedOut: boolean
+  }
+}
+
 export type PluginOptions = {
   key: string
   pluginName: string
@@ -33,8 +45,32 @@ export type PluginOptions = {
     registerEvents?: (io: SocketServer, eventbus: any) => void
     createRooms?: (io: SocketServer) => void
   }
+  /**
+   * Loader-owned mutable bookkeeping (not part of the public plugin API).
+   * Plugin code should ignore; the loader reads this after `index.ts` returns.
+   */
+  _loaderInternal?: PluginLoaderInternalState
+}
+
+/** Options when a plugin customizes frontend generation metadata. */
+export type RegisterForFrontendGenerationOptions = {
+  routePrefix?: string
+  entityMapping?: Record<string, string>
+  customConfig?: {
+    broadcast?: boolean
+    channels?: Record<string, string>
+    operationMapping?: Record<string, string>
+  }
 }
 
+/**
+ * Argument to `fastify.registerForFrontendGeneration`.
+ * Pass `false` to opt out of frontend generation registration for this plugin.
+ */
+export type RegisterForFrontendGenerationInput =
+  | RegisterForFrontendGenerationOptions
+  | false
+
 export type PluginFastifyInstance = {
   /* ROUTES */
   register: (
@@ -87,7 +123,9 @@ export type PluginFastifyInstance = {
   eventbus: EventEmitter
 
   registerPluginContract: (contractData: PluginContract) => void
-  registerForFrontendGeneration: (options: any) => any
+  registerForFrontendGeneration: (
+    options?: RegisterForFrontendGenerationInput,
+  ) => void
 
   fastify: FastifyInstance
   custom: Record<any, any>

package/services/backend/src/core/sockets/createSystemEventHandlers.ts

@@ -9,7 +9,7 @@ export const createSystemEventHandlers = (fastify: FastifyInstance) => {
     // TODO rework this to handle spaces instead of project and in the future document rooms -> y.js?
     // Is this even used? SocketManager also has wss.emit
     fastify.log.debug(
-      `[Socket] sendToChannel ${key} to room ${payload.project} and ${payload.workSessionId}`,
+      `[Socket] sendToChannel ${key} to room ${payload.project}${payload.workSessionId ? ' and workSession ' + payload.workSessionId : ''}`,
     )
     if (payload.project) {
       wss.in(payload.project).emit(key, payload)
@@ -22,15 +22,15 @@ export const createSystemEventHandlers = (fastify: FastifyInstance) => {
   }
 
   return {
-    broadcastDataUpdatedHandler: (payload: FrontendPayload<unknown>): void => {
+    broadcastDataUpdated: (payload: FrontendPayload<unknown>): void => {
       fastify.log.info(`[Socket] Push onData: ${payload.appSessionId}`)
       sendToChannel(payload, "data")
     },
-    broadcastDataCreatedHandler: (payload: FrontendPayload<unknown>): void => {
+    broadcastDataCreated: (payload: FrontendPayload<unknown>): void => {
       fastify.log.info(`[Socket] Push onCreate: ${payload.appSessionId}`)
       sendToChannel(payload, "dataCreated")
     },
-    broadcastDataDeletedHandler: (payload: FrontendPayload<unknown>): void => {
+    broadcastDataDeleted: (payload: FrontendPayload<unknown>): void => {
       fastify.log.info(`[Socket] Push onDelete: ${payload.appSessionId}`)
       sendToChannel(payload, "dataDeleted")
     },

package/services/backend/src/core/sockets/socketManager.ts

@@ -8,8 +8,7 @@ import { buildWorkSessionJoinPayload } from "./workSessionJoinPayload"
 
 interface JoinPayload {
   roomId?: string
-  token?: string
-  tenantId?: string
+  bootstrap?: boolean
 }
 
 interface ProjectResponse {
@@ -29,7 +28,25 @@ const isSocketAuthenticated = (
 }
 
 /**
- * Load project by ID or get main project
+ * Guard for explicit room joins. Server-assigned readMain joins skip this.
+ */
+const assertCanJoinProject = async (
+  fastify: FastifyInstance,
+  socket: Socket,
+  spaceId: string,
+): Promise<ProjectResponse> => {
+  const project = await loadProject(fastify, spaceId)
+  if (!project) {
+    throw new Error("Space not found")
+  }
+
+  // TODO: here we add the guard if a user is allowed to join a specific space or not
+
+  throw new Error("Not allowed to join this space")
+}
+
+/**
+ * Load project by ID or assign main project when roomId is omitted
  */
 const loadProject = async (
   fastify: FastifyInstance,
@@ -379,34 +396,66 @@ const handleAuthenticatedUserJoin = async (
   socket: Socket,
   payload: JoinPayload,
 ): Promise<void> => {
-  const { roomId: spaceId } = payload
-  const project = await loadProject(fastify, spaceId)
-
-  if (!project) {
-    socket.emit("error", {
-      error: {
-        msg: spaceId
-          ? "Space not found or access denied"
-          : "No suiting space found. Something seems wrongly configured!",
-      },
-    })
-    return
+  const explicitSpaceId = payload.roomId
+  const bootstrap = payload.bootstrap ?? !explicitSpaceId
+  let spaceId = explicitSpaceId
+  let project: ProjectResponse | null = null
+
+  if (explicitSpaceId) {
+    try {
+      project = await assertCanJoinProject(fastify, socket, explicitSpaceId)
+      spaceId = explicitSpaceId
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message : "Access denied"
+      const code = message === "Space not found" ? "NOT_FOUND" : "FORBIDDEN"
+      socket.emit("joinFailed", {
+        roomId: explicitSpaceId,
+        code,
+        message,
+      })
+      return
+    }
+  } else {
+    // per default we let every user join the default space for the app
+    project = await loadProject(fastify)
+    if (!project) {
+      socket.emit("joinFailed", {
+        code: "NOT_FOUND",
+        message: "No default space found. Something seems wrongly configured!",
+      })
+      return
+    }
+    spaceId = project._id
   }
 
-  socket.join(project._id)
-  socket.data = socket.data || {}
-  socket.data.project = project._id
+  await socket.join(spaceId)
+  if (!socket.data.projects) {
+    socket.data.projects = new Set<string>()
+  }
+  socket.data.projects.add(spaceId)
 
-  // Join user's owned work sessions
-  const decodedToken = socket.decoded_token as any
+  const decodedToken = socket.decoded_token as { _id?: string }
   const userId = decodedToken?._id
-  if (userId) {
+  if (bootstrap && userId) {
     await joinOwnedWorkSessions(fastify, socket, userId)
   }
 
-  const responseData = await buildAuthenticatedUserResponse(fastify, project)
-  socket.emit("joinConfirmation", responseData)
-  fastify.log.info(`[Socket] Socket ${socket.id} joined room ${project._id}`)
+  const responseData =
+    bootstrap && project
+      ? await buildAuthenticatedUserResponse(fastify, project)
+      : project
+        ? { project }
+        : {}
+
+  socket.emit("joinConfirmation", {
+    ...responseData,
+    roomId: spaceId,
+    bootstrap,
+  })
+  fastify.log.info(
+    `[Socket] Socket ${socket.id} joined room ${spaceId}, rooms: ${[...socket.rooms].join(", ")}`,
+  )
 }
 
 /**
@@ -418,20 +467,18 @@ const registerSocketEvents = (fastify: FastifyInstance): void => {
   const requiresAuth = configService.isAuthRequired()
 
   wss.on("connection", (socket: Socket) => {
-    const isAuthenticated = isSocketAuthenticated(socket, requiresAuth)
-
     fastify.log.info(`[Socket] Connected ${socket.id}`)
     socket.emit("socketEstablished", { id: socket.id })
 
-    if (!isAuthenticated && requiresAuth) {
+    if (!isSocketAuthenticated(socket, requiresAuth) && requiresAuth) {
       fastify.log.warn(`[Socket] Unauthenticated connection ${socket.id}`)
       socket.emit("authenticationRequired", {
         message: "Authentication required",
       })
     }
 
-    socket.on("join", async (payload: JoinPayload) => {
-      if (requiresAuth && !isAuthenticated) {
+    socket.on("join", async (payload: JoinPayload = {}) => {
+      if (requiresAuth && !isSocketAuthenticated(socket, requiresAuth)) {
         socket.emit("authenticationFailed", {
           message: "Authentication required to join room",
         })
@@ -451,6 +498,7 @@ const registerSocketEvents = (fastify: FastifyInstance): void => {
 
     socket.on("leave", (room: string) => {
       socket.leave(room)
+      socket.data.projects?.delete(room)
       socket.emit("leaveConfirmation", room)
       wss.in(room).emit("memberLeft", {
         room,
@@ -465,9 +513,9 @@ const registerSocketEvents = (fastify: FastifyInstance): void => {
 
   // Register system event handlers
   const systemEvents = {
-    broadcastDataUpdated: eventbusHandler.broadcastDataUpdatedHandler,
-    broadcastDataCreated: eventbusHandler.broadcastDataCreatedHandler,
-    broadcastDataDeleted: eventbusHandler.broadcastDataDeletedHandler,
+    broadcastDataUpdated: eventbusHandler.broadcastDataUpdated,
+    broadcastDataCreated: eventbusHandler.broadcastDataCreated,
+    broadcastDataDeleted: eventbusHandler.broadcastDataDeleted,
     broadcastTagCreated: eventbusHandler.broadcastTagCreated,
     broadcastTagDeleted: eventbusHandler.broadcastTagDeleted,
     broadcastUserCreated: eventbusHandler.broadcastUserCreated,

package/services/backend/src/core/sockets/socketTypes.ts

@@ -2,6 +2,12 @@ import type { DefaultEventsMap, EventsMap } from "socket.io/dist/typed-events"
 import type { VerifyPayloadType } from "@fastify/jwt"
 
 declare module "socket.io" {
+  interface SocketData {
+    projects?: Set<string>
+    ownedSessions?: string[]
+    session?: string
+  }
+
   interface Socket<
     ListenEvents extends EventsMap = DefaultEventsMap,
     EmitEvents extends EventsMap = ListenEvents,

package/services/backend/src/core/validation/schemaGenerator.ts

@@ -81,7 +81,10 @@ export const generateSharedSchemas = async (sharedDir: string) => {
 
   // Generate index files
   await generateCoreTypesIndex(sharedDir)
-  await generatePluginTypesIndex(sharedDir)
+  if (process.env.RACLETTE_CORE_ABSOLUTE_PATH?.includes("node_modules")) {
+    // only generate this for non-linked core to prevent mixup of app content in code
+    await generatePluginTypesIndex(sharedDir)
+  }
   await generateMainTypesIndex(sharedDir)
 }
 
@@ -268,7 +271,10 @@ const generateCoreTypesIndex = async (sharedDir: string) => {
     .join("\n")
 
   // Write index file
-  await fs.writeFile(path.join(coreDir, "index.ts"), generateTypesFileContent(exportStatements))
+  await fs.writeFile(
+    path.join(coreDir, "index.ts"),
+    generateTypesFileContent(exportStatements),
+  )
 }
 
 // Helper function to generate the plugins index.ts
@@ -302,7 +308,8 @@ const generatePluginTypesIndex = async (sharedDir: string) => {
 
 // Helper function to generate the main types/index.ts
 const generateMainTypesIndex = async (sharedDir: string) => {
-  const content = generateTypesFileContent(`// Import and re-export all core types
+  const content =
+    generateTypesFileContent(`// Import and re-export all core types
 export type * from './core'
 
 // Import and re-export all plugin types

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

@@ -150,7 +150,7 @@ export class ProjectService {
   }
 
   /**
-   * Core function to get a specific project (returns raw data)
+   * Core function to the main project (used until spaces are coming)
    */
   async _readMainProject(fastify: PluginFastifyInstance): Promise<ProjectType> {
     try {

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

@@ -42,8 +42,6 @@ const racletteCorePlugin = async (
 
   // Register the complete contract
   fastify.registerPluginContract(pluginContract)
-
-  fastify.registerForFrontendGeneration({})
 }
 
 export default racletteCorePlugin

package/services/backend/src/modules/authentication/index.ts

@@ -4,6 +4,11 @@ import fastifyPlugin from "fastify-plugin"
 import type { User } from "@shared/types"
 import configService from "@c/config/configService"
 import type { WorkSessionDoc } from "@/corePlugins/raclette__core/backend/datatypes/workSession/workSession.schema"
+import {
+  ADMIN_SYSTEM_TAG_QUERY,
+  type AdminTaggableUser,
+  userHasAdminTag,
+} from "@shared/helper/adminTag"
 import { ForbiddenError } from "@/utils/errors"
 
 const WORK_SESSION_COLLECTION = "raclette__core-worksession"
@@ -87,25 +92,20 @@ export const authenticatedOrWorksession = async (
     const { _id } = req.user
     const adminTag = await fastify.database
       .collection("raclette__core-tag")
-      .findOne({ title: "ADMIN", locked: true, type: "system" })
-    let isAdmin = false
+      .findOne(ADMIN_SYSTEM_TAG_QUERY)
     const user = await fastify.database
       .collection("raclette__core-user")
       .findOne({ _id }, { projection: { password: 0, resetKey: 0 } })
-    if (user && user.tags && adminTag) {
-      user.tags.forEach((tag: string) => {
-        if (adminTag._id === tag) isAdmin = true
-      })
+    if (!user) {
+      fastify.log.error("User not found")
+      return res.status(401).send({ message: "User not found" })
     }
+    const isAdmin = userHasAdminTag(user as AdminTaggableUser, adminTag)
     if (isAdminTagRequired && !isAdmin) {
       fastify.log.error("User not allowed in workbench")
       return res.status(403).send({ message: "User not allowed in workbench" })
     }
     if (isAdmin) user.isAdmin = true
-    if (!user) {
-      fastify.log.error("User not found")
-      return res.status(401).send({ message: "User not found" })
-    }
     const account = await fastify.database
       .collection("raclette__core-account")
       .findOne({ _id: user.account })
@@ -244,24 +244,21 @@ export const authenticate = async (
       const { _id } = req.user
       const adminTag = await fastify.database
         .collection("raclette__core-tag")
-        .findOne({ title: "ADMIN", locked: true, type: "system" })
+        .findOne(ADMIN_SYSTEM_TAG_QUERY)
       // IMPORTANT
       // due to some very weird behaviour, mongoose always returns empty results
       // so we are using mongodb directly until we fix this
-      let isAdmin = false
       const user = await fastify.database
         .collection("raclette__core-user")
         .findOne(
           { _id },
           { projection: { password: 0, resetKey: 0 } }, // Exclude sensitive fields
         )
-      if (user && user.tags && adminTag) {
-        user.tags.forEach((tag) => {
-          if (adminTag._id === tag) {
-            isAdmin = true
-          }
-        })
+      if (!user) {
+        fastify.log.error("User not found")
+        throw new Error("User not found")
       }
+      const isAdmin = userHasAdminTag(user as AdminTaggableUser, adminTag)
       if (isAdminTagRequired && !isAdmin) {
         fastify.log.error("User not allowed in workbench")
         throw new Error("User not allowed in workbench")
@@ -270,11 +267,6 @@ export const authenticate = async (
         user.isAdmin = true
       }
 
-      if (!user) {
-        fastify.log.error("User not found")
-        throw new Error("User not found")
-      }
-
       const account = await fastify.database
         .collection("raclette__core-account")
         .findOne({ _id: user.account })

package/services/backend/src/shared/helper/adminTag.ts

@@ -0,0 +1,34 @@
+export const ADMIN_SYSTEM_TAG_QUERY = {
+  title: "ADMIN",
+  locked: true,
+  type: "system",
+} as const
+
+export type SystemAdminTagLike = {
+  title?: string
+  locked?: boolean
+  type?: string
+}
+
+export type AdminTaggableUser = {
+  tags?: string[]
+}
+
+export function isSystemAdminTag(
+  tag: SystemAdminTagLike | null | undefined,
+): boolean {
+  if (!tag) return false
+  return (
+    tag.title === ADMIN_SYSTEM_TAG_QUERY.title &&
+    tag.locked === ADMIN_SYSTEM_TAG_QUERY.locked &&
+    tag.type === ADMIN_SYSTEM_TAG_QUERY.type
+  )
+}
+
+export function userHasAdminTag(
+  user: AdminTaggableUser | null | undefined,
+  adminTag: { _id: string } | null | undefined,
+): boolean {
+  if (!user?.tags?.length || !adminTag?._id) return false
+  return user.tags.includes(adminTag._id)
+}

package/services/backend/src/shared/types/plugins/index.ts

@@ -1,9 +1 @@
-/**
- * ⚠️ WARNING: THIS FILE IS AUTO-GENERATED ⚠️
- * 
- * This file is generated by the type generation system.
- * Any manual changes will be overwritten on next server start and should always be committed.
- * 
- */
-
-export type * from './pacifico__openstack-billing-dashboard'
+export type {}

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

@@ -19,7 +19,7 @@ export const createRequestParams = (
     appRequestCode: req.headers["app-request-code"] ?? "",
     requestId: req.id ?? "",
     type: "",
-    broadcast: req.headers["app-broadcast-channels"] ?? false,
+    broadcast: req.headers["app-broadcast-channels"]?.length ? true : false,
     project: projectId,
     userId: req.user?.id,
     options: {},