Monstermq Graphql Config

mutation Login($username: String!, $password: String!) {
  login(username: $username, password: $password) {
    token
    user {
      username
      isAdmin
    }
  }
}

Authorization: Bearer <JWT_TOKEN_STRING>
Content-Type: application/json

mutation PublishMessage($input: PublishInput!) {
  publish(input: $input) {
    success
    topic
    timestamp
    error
  }
}

{
  "input": {
    "topic": "factory/line1/temperature",
    "payload": "{\"value\": 23.5, \"unit\": \"C\"}",
    "format": "JSON",
    "qos": 1,
    "retained": true
  }
}

mutation PublishBatch($inputs: [PublishInput!]!) {
  publishBatch(inputs: $inputs) {
    success
    topic
    timestamp
    error
  }
}

# Remove active/persistent client sessions
mutation RemoveSessions($clientIds: [String!]!) {
  session {
    removeSessions(clientIds: $clientIds) {
      success
      removedCount
      message
    }
  }
}

# Purge offline client message queues
mutation PurgeQueue($clientId: String) {
  purgeQueuedMessages(clientId: $clientId) {
    success
    message
    purgedCount
  }
}

# Create User Account
mutation CreateUser($input: CreateUserInput!) {
  user {
    createUser(input: $input) {
      success
      message
    }
  }
}

# Update User Permissions
mutation UpdateUser($input: UpdateUserInput!) {
  user {
    updateUser(input: $input) {
      success
      message
    }
  }
}

# Change Password
mutation ChangePassword($input: SetPasswordInput!) {
  user {
    setPassword(input: $input) {
      success
      message
    }
  }
}

# Delete User
mutation DeleteUser($username: String!) {
  user {
    deleteUser(username: $username) {
      success
      message
    }
  }
}

# Create ACL Rule (Topic Access Control)
mutation CreateAclRule($input: CreateAclRuleInput!) {
  user {
    createAclRule(input: $input) {
      success
      message
    }
  }
}

# Create Archive Group
mutation CreateArchiveGroup($input: CreateArchiveGroupInput!) {
  archiveGroup {
    create(input: $input) {
      success
      message
    }
  }
}

# Enable / Disable Archive Group
mutation ToggleArchiveGroup($name: String!, $enable: Boolean!) {
  archiveGroup {
    enable(name: $name) # or disable(name: $name)
    {
      success
      message
    }
  }
}

mutation CreateOpcUaClient($input: OpcUaClientConfigInput!) {
  createOpcUaClientConfig(input: $input) {
    name
    endpointUrl
    enabled
    subscriptions {
      nodeId
      mqttTopic
    }
  }
}

{
  "input": {
    "name": "opcua-plc1",
    "endpointUrl": "opc.tcp://192.168.1.100:4840",
    "securityPolicy": "None",
    "enabled": true,
    "nodeId": "node-1",
    "subscriptions": [
      {
        "nodeId": "ns=2;s=Channel1.Device1.Tag1",
        "mqttTopic": "opcua/plc1/tag1",
        "samplingInterval": 1000
      }
    ]
  }
}

mutation CreatePlc4xClient($input: Plc4xClientConfigInput!) {
  createPlc4xClientConfig(input: $input) {
    name
    connectionString
    enabled
  }
}

mutation CreateWinCCOaClient($input: WinCCOaClientConfigInput!) {
  createWinCCOaClientConfig(input: $input) {
    name
    enabled
  }
}

mutation CreateWinCCUaClient($input: WinCCUaClientConfigInput!) {
  createWinCCUaClientConfig(input: $input) {
    name
    enabled
  }
}

mutation CreateFlowClass($input: FlowClassInput!) {
  flow {
    createClass(input: $input) {
      name
      namespace
      version
    }
  }
}

mutation DeployFlowInstance($input: FlowInstanceInput!) {
  flow {
    createInstance(input: $input) {
      name
      enabled
      nodeId
    }
  }
}

# Control Flow Execution
mutation ControlFlow($name: String!) {
  flow {
    enableInstance(name: $name) # or disableInstance(name: $name)
    {
      name
      enabled
    }
  }
}

mutation CreateAgent($input: AgentInput!) {
  agent {
    create(input: $input) {
      name
      namespace
      nodeId
      enabled
      provider
      model
    }
  }
}

mutation StartAgent($name: String!) {
  agent {
    start(name: $name) {
      name
      enabled
    }
  }
}

mutation CreateGenAiProvider($input: GenAiProviderInput!) {
  createGenAiProvider(input: $input) {
    name
    providerType
    baseUrl
  }
}

mutation RegisterTopicSchema($input: TopicSchemaInput!) {
  createTopicSchema(input: $input) {
    topicFilter
    description
  }
}

import requests

GRAPHQL_URL = "http://localhost:4000/graphql"

# 1. Login to get JWT Token
login_query = """
mutation Login($user: String!, $pass: String!) {
  login(username: $user, password: $pass) {
    token
  }
}
"""
res = requests.post(GRAPHQL_URL, json={"query": login_query, "variables": {"user": "admin", "pass": "admin123"}})
token = res.json()["data"]["login"]["token"]

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {token}"
}

# 2. Publish a Message
pub_query = """
mutation Publish($input: PublishInput!) {
  publish(input: $input) {
    success
    topic
    timestamp
  }
}
"""
pub_vars = {
    "input": {
        "topic": "factory/line1/status",
        "payload": "{\"state\": \"RUNNING\", \"speed\": 120}",
        "qos": 1,
        "retained": True
    }
}
res = requests.post(GRAPHQL_URL, json={"query": pub_query, "variables": pub_vars}, headers=headers)
print("Publish Result:", res.json())

curl -X POST http://localhost:4000/graphql \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <TOKEN>" \
  -d '{
    "query": "mutation Publish($input: PublishInput!) { publish(input: $input) { success topic timestamp } }",
    "variables": {
      "input": {
        "topic": "cmd/test",
        "payload": "{\"action\":\"RESET\"}",
        "qos": 1
      }
    }
  }'