APIs

Devices and protocols

Helpers for device, plant, and telecom payloads. They parse and build envelopes; they do not open sockets by themselves. Wire a matching connector (MQTT, CoAP, OPC UA, BACnet/IP, SIP, SMPP) as the source or destination, then use these calls inside the transform.

const env = sirius.mqtt.parse(sirius.json.decode(msg.raw));
if (!sirius.mqtt.topic_match("orders/+/created", env.topic)) {
  result = { message: msg.raw };
} else {
  result = { message: env.payload };
}

This page lists 44 symbols. The same catalog drives Studio autocomplete.

See also: Overview · Core · Standards · I/O and runtime

`sirius.mqtt`

Symbol	Signature	Returns	Summary
`sirius.mqtt.build`	`sirius.mqtt.build(envelope)`	object	validate + build a canonical publish envelope (errors on bad topic/qos)
`sirius.mqtt.parse`	`sirius.mqtt.parse(envelope)`	object	normalize a loose publish envelope into { topic, qos, retained, payload, properties }
`sirius.mqtt.props_get`	`sirius.mqtt.props_get(properties, key)`	string	read an MQTT5 user property by key (object or [{key,value}] form)
`sirius.mqtt.props_set`	`sirius.mqtt.props_set(properties, key, value)`	object	set an MQTT5 user property, returning the updated property object
`sirius.mqtt.qos_valid`	`sirius.mqtt.qos_valid(qos)`	bool	report whether a QoS value is 0, 1, or 2
`sirius.mqtt.topic_match`	`sirius.mqtt.topic_match(filter, topic)`	bool	match an MQTT subscription filter (+/# wildcards) against a topic
`sirius.mqtt.topic_valid`	`sirius.mqtt.topic_valid(name, is_filter?)`	{ ok, error? }	validate a topic name, or a subscription filter when is_filter=true

`sirius.coap`

Symbol	Signature	Returns	Summary
`sirius.coap.build`	`sirius.coap.build(message)`	string (base64)	encode a structured message into a base64 CoAP datagram
`sirius.coap.code_name`	`sirius.coap.code_name(code)`	string	render a CoAP code as a method name or dotted c.dd form
`sirius.coap.code_num`	`sirius.coap.code_num(name)`	int	parse a method name / dotted code / integer into a CoAP code number
`sirius.coap.content_format`	`sirius.coap.content_format(value)`	string	int`
`sirius.coap.option_name`	`sirius.coap.option_name(number)`	string	return the registered name for a CoAP option number
`sirius.coap.parse`	`sirius.coap.parse(raw_b64)`	object	decode a base64 CoAP datagram into a structured message
`sirius.coap.validate`	`sirius.coap.validate(raw_b64)`	{ ok, error? }	structurally validate a base64 CoAP datagram

`sirius.opcua`

Symbol	Signature	Returns	Summary
`sirius.opcua.nodeid_format`	`sirius.opcua.nodeid_format(node_id)`	string	render a NodeId object back to a string
`sirius.opcua.nodeid_parse`	`sirius.opcua.nodeid_parse(node_id)`	object	parse an OPC UA NodeId string into { ns, type, id }
`sirius.opcua.sample`	`sirius.opcua.sample(sample)`	object	normalize/validate a Sample object
`sirius.opcua.status_name`	`sirius.opcua.status_name(code)`	string	map an OPC UA StatusCode to a symbolic name
`sirius.opcua.variant_decode`	`sirius.opcua.variant_decode(variant)`	value	normalize a { type, value } variant to its native value
`sirius.opcua.variant_encode`	`sirius.opcua.variant_encode(value, type)`	{ type, value }	validate + normalize a value against a Variant built-in type

`sirius.bacnet`

Symbol	Signature	Returns	Summary
`sirius.bacnet.cov_samples`	`sirius.bacnet.cov_samples(notification)`	array	flatten a COV notification into [{ object_id, property, value }]
`sirius.bacnet.objectid_format`	`sirius.bacnet.objectid_format(object_id)`	string	render { type, instance } to ‘type-name:instance’
`sirius.bacnet.objectid_parse`	`sirius.bacnet.objectid_parse(object_id)`	object	parse ‘analog-value:1’ into { type, type_name, instance }
`sirius.bacnet.priority_array`	`sirius.bacnet.priority_array(array)`	object	normalize a 16-slot priority array + resolve the active slot
`sirius.bacnet.property_parse`	`sirius.bacnet.property_parse(property)`	{ id, name }	map a property name<->enum, returning { id, name }
`sirius.bacnet.value_decode`	`sirius.bacnet.value_decode(value)`	value	return the native value from a { type, value } object
`sirius.bacnet.value_encode`	`sirius.bacnet.value_encode(value, type)`	{ type, value }	coerce a value to a BACnet datatype, returning { type, value }

`sirius.sip`

Symbol	Signature	Returns	Summary
`sirius.sip.build`	`sirius.sip.build(message)`	string	build a SIP request/response from a structured object
`sirius.sip.header_get`	`sirius.sip.header_get(raw, name)`	string	read the first value of a header (case-insensitive)
`sirius.sip.header_set`	`sirius.sip.header_set(raw, name, value)`	string	set a header value and return the rebuilt message
`sirius.sip.parse`	`sirius.sip.parse(raw)`	object	parse a raw SIP message into a structured object
`sirius.sip.uri_format`	`sirius.sip.uri_format(uri)`	string	render a SIP URI object back to a string
`sirius.sip.uri_parse`	`sirius.sip.uri_parse(uri)`	object	parse a SIP/SIPS URI into { scheme, user, host, port, params }
`sirius.sip.validate`	`sirius.sip.validate(raw)`	{ ok, error?, missing? }	validate a SIP request carries the required headers

`sirius.smpp`

Symbol	Signature	Returns	Summary
`sirius.smpp.command_name`	`sirius.smpp.command_name(command_id)`	string	map an SMPP command_id to its name
`sirius.smpp.dcs_decode`	`sirius.smpp.dcs_decode(data_b64, coding)`	string	decode base64 message bytes to UTF-8 per data_coding (0/3/8)
`sirius.smpp.dcs_encode`	`sirius.smpp.dcs_encode(text, coding)`	string (base64)	encode UTF-8 to base64 message bytes per data_coding (0/3/8)
`sirius.smpp.dlr_parse`	`sirius.smpp.dlr_parse(text)`	object	parse an SMPP delivery-receipt short_message into fields
`sirius.smpp.message`	`sirius.smpp.message(pdu)`	object	extract src/dst/text/is_dlr from a submit_sm/deliver_sm PDU object
`sirius.smpp.pdu_parse`	`sirius.smpp.pdu_parse(raw_b64)`	object	decode a base64 SMPP PDU header + body
`sirius.smpp.tlv_get`	`sirius.smpp.tlv_get(tlv_b64, tag)`	string (hex)	read an optional-parameter (TLV) value (hex) by tag
`sirius.smpp.tlv_set`	`sirius.smpp.tlv_set(tlv_b64, tag, value_hex)`	string (base64)	append/replace a TLV (value hex) and return updated base64
`sirius.smpp.udh_join`	`sirius.smpp.udh_join(parts)`	string	reassemble concatenated-SMS parts into the original text
`sirius.smpp.udh_split`	`sirius.smpp.udh_split(text, ref, coding?)`	array	segment a long message into concatenated-SMS parts