The jwt token used by this client (if any).

The token property is initialised by options.token in constructor.

Set (update or clear) the jwt token used by this client (if any)

The domain effectively used by this client, with the following precedence:

• the domain asserted by the jwt token token
• the domain as set by the constructor, setDomain or domain
• the domain as set from tenant settings by withSettings (key waylay_domain)

The domain property is initialised by options.domain in constructor.

Set the (default) domain.

Setting this property does NOT overwrite a domain asserted by the token.

Type: (string | null)

Obtain a login token using username and password.

As a side effect, the token is used by this client for subsequent calls (token)

const { access_token, expires_at } = waylay.login('my-username', 'and-password')
console.log(`token ${access_token} will expire at ${new Date(expires_at)}`)

Authenticate this client with an api key and secret.

Ping your Waylay instance

Retrieve your profile information

Update this client with organisation settings from the organisationSettings service, in that way configuring default endpoints.

See withSettings to see how the retrieved settings impact the lookup of services.

Update this client with organisation settings for the default endpoints (globalSettings). Any previous settings are overwritten by this call.

Any service on this client resolves its baseUrl with the following precedence:

• the constructor argument options.<service>.baseUrl
• the api gateway endpoint with prefix set by constructor argument options.gateway or the organisation setting settings.waylay_gateway (see gateway)
• the organisation setting settings.waylay_<service> as described below, and set by this method
• the waylay default for the service as described below
• the default baseUrl of this client (see below, depends on api and domain configuration)

The organisation settings can be intialised by the options.globalSettings argument in the constructor.

A user can initialise organisation settings either from an existing object:

const waylay = new Waylay({token, globalSettings: myCachedSettings})

or using the client itself (using the default OrganisationSettings service, requires an async call)

const waylay = await new Waylay({token}).loadSettings()

or explicitely using this method.

Note that any waylay plugin sandbox (e.g. for sensors and actuators) does this initialization for you before handing over the waylay client.

This call only affects the organisation setting used by this client object. See organisationSettings to manage the settings for all your users.

Retrieve the organisation settings.

The default base url for (unconfigured) services, using the api and domain configuration. Uses the first that is defined from:

• the api.baseUrl constructor argument of this client
• the settings.waylay_api organisation setting
• the domain constructor argument of this client
• the settings.waylay_domain organisation setting
• the domain as stated in the current JWT Token

Note the token domain has least precedence, contrary to the definition of the domain property, where it has greatest precendence.

Type: string

Set the gateway url to be used by this client. Intialized by the options.gateway constructor argument.

Can be a gateway url prefix, hostname or id (production, on-demand, ...).

If set, the client uses the API gateway on each service, (unless overridden by options.<service>.baseUrl). In that case organisation settings for the service endpoints are ignored.

See withSettings for the impact on service endpoint resolution.

Type: (string | undefined)

Get the service gateway url used by this client. This is, in descending priority:

• the options.gateway constructor argument, which can be changed by setting the gateway attribute.
• the waylay_gateway global setting (see withSettings or options.globalSettings contructor argument)
• the default production gateway api.waylay.io (only if options.enforceGateway is true and options.enforceConfigured is false)

Note that, if defined, all services use this gateway, unless an explicit overide was set (global settings are ignored, see withSettings).

Type: (string | undefined)

Retrieve a series of measurement from a resource

Alias of getMessage()

await waylay.data.getSeries('testresource',{limit: 10, window: 'PT1H'})

// Response on resolve
[{
  "temperature": 32.22983748538228,
 "timestamp": 1617093236578
},{...},{...},{...},{...},{...},{...},{...},{...},{...}]

Post a series of measurement to one or multiple resources. The resource should be defined in the message object. See https://docs.waylay.io/#/api/broker/?id=posting-array-of-data

await waylay.data.postSeries([
{
        "resource": "testresource",
        "test": 1,
        "timestamp": 1617088527380
    },
{
        "resource": "testresource",
        "test": 2,
        "timestamp": 1617088527381
    }
])

// Response on resolve
{
   "message": "Batch uploaded 2 messages for resource testresource",
   "content": {}
}

Post a series of measurement to a resource

Alias of postMessages()

See https://docs.waylay.io/#/api/broker/?id=posting-data-towards-broker

await waylay.data.postSeries('testresource',
 {
   'test': 1
 }
 , { store: true, forward: true })

// Response on resolve
{
 "message": "Published message async for testresource",
 "content": {
   "test": 1,
  "timestamp": 1617108869013
  }
}

Remove a series of data from a resource

Query the time series storage for a particular resource.

To disable aggregation, pass the value none for aggregate in the options object.

See https://docs.waylay.io/#/api/broker/?id=time-series-data-retrieval

getMetricSeries('resource', 'metric', { aggregate: 'none' })

getMetricSeries('resource', 'metric', { aggregate: 'median', grouping: 'PT15M' })

await waylay.data.getMetricSeries('testresource','test', { aggregate: 'max',from: 1617088439000, window:'PT1H', grouping: 'PT1H' })

// Response on resolve
{
  "query": {
  "from": 1617088439000,
  "until": 1617110061759,
  "metric": "test",
  "aggregates": [
    "max"
  ],
  "grouping": "PT1H",
  "resources": [
    "testresource"
  ],
  "aggregate": "max"
 },
"series": [
 [1617088439000,2],[...],[...],[...],[...],[...],
]
}

Query the time series storage for the latest n datapoints for a particular metric from a resource

See https://docs.waylay.io/#/api/broker/#post-timeseries-query

await waylay.data.getLastDatapointsForMetric('testresource','test', { limit: 10})
{
  "query": {
  "from": null,
  "until": 1617172322107,
  "metric": "test",
  "aggregates": null,
  "grouping": "auto",
  "resources": [
    "testresource"
  ],
  "limit": 10
 },
 "series": [[...],[...],[...],[...],[...],[...],[...],[...],[...],[...]]
}

Query the time series storage for the latest n datapoints for a particular resource and metric and get them raw

See https://docs.waylay.io/#/api/broker/#getting-time-series-data

await waylay.data.getDatapointsForMetricRaw('testresource','test', { limit: 10})

{
 "query": {
   "from": 1616569296535,
   "until": 1617174096535,
   "metric": "test",
   "aggregates": null,
   "grouping": "auto",
   "resources": [
     "testresource"
   ],
   "limit": 10
 },
 "series": [
   [1617093236579, 1],[...],[...],[...],[...],[...],[...],[...],[...],[...],
 ]
}

Perform a free-form time series query.

This method allows aggregating a metric over one or more resources, using one or more aggregate operations.

An example query object would be as follows:

The response includes a 'series' field which contains an array of measurement arrays. Each of the nested measurement arrays contains a timestamp value at index 0, and then one value per aggregate in the order that the aggregates were supplied in the request. In the example request above, this results in values containing

An example of output from the above query would be as follows:

See https://docs.waylay.io/#/api/broker/?id=time-series-data-retrieval for more information on the query definition.

await waylay.data.queryTimeSeries({
     "window": "PT2H",
     "resources": ["testresource"],
     "aggregates": ["mean", "min", "max"],
     "metric": "test",
    "grouping": "PT1M"
})

// Response on resolve
{
"query": {
  "from": 1617167966555,
  "until": 1617175166555,
  "metric": "test",
  "aggregates": [
    "mean",
    "min",
    "max"
  ],
  "grouping": "PT1M",
  "resources": [
    "testresource"
  ]
 },
 "series": [Array(120)]
}

You can retrieve messages for multiple resources from the message storage in one REST api call.

The messages will always be grouped per resource. They will be sorted by timestamp in descending order.

An example query object would be as follows:

See https://docs.waylay.io/#/api/broker/#querying-messages-for-multiple-resources for more information on the query definition and response payload format.

Retrieve the last measurement for a metric of a resource

await waylay.data.getLastMetric('testresource', 'test')

// Response on resolve
{
  "test": [
   1
  ],
 "timestamp": 1617108869013
}

Retrieve the last message sent to a resource

await waylay.data.getLatestDocument('testresource')

// Response on resolve
{
 "test": 1,
 "timestamp": 1617108869013
}

Retrieve up to the last 100 messages sent to a resource, allowing an optional filter object.

see https://docs.waylay.io/#/api/broker/#querying-messages-for-multiple-resources

await waylay.data.getLatestMessages('testresource', { limit: 10 })

// Response on resolve
[
   {
    "test": 1,
   "timestamp": 1617108869013
  },
  {
    "test": 1,
    "timestamp": 1617093236579
  },{...},{...},{...},{...},{...},{...},{...},{...}
]

Remove all data and messages for a resource

await waylay.data.remove('testresource')

// Response on resolve
{
   "message": "Deleted messages, series and all metrics for testresource"
}

Get data websocket stream path

baseUrl abstraction to make sure that this entity first falls back to the api/engine config

Create a new Waylay resource

await waylay.resources.create({ id: 'testSDKDocs', name: 'test' })

// Response on resolve
{
  "statusCode": 201,
  "uri": "/api/resources/testSDKDocs",
  "entity": {
    "id": "testSDKDocs",
    "name": "test"
  }
}

Retrieve info from a resource

await waylay.resources.get('testresource')

//Response on resolve
{
 "id": "testresource",
 "resourceTypeId": "SampleResourceType"
 "parentId": "testresourceParent"
}

Retrieves the child resources of the specified resource.

await waylay.resources.children('testresource', { skip: 0, limit: 100, denormalized: false })

// Response on resolve
{
 "values": [{...},{...},{...},{...},{...}],
 "skip": 0,
 "limit": 100,
 "total": 5
}

Retrieves the parent resource of the specified resource.

await waylay.resources.parent('testresource')

// Response on resolve
{
  "id": "testresourceParent"
  "resourceTypeId": "SampleResourceType"
}

Retrieves the resources that where referenced by the specified resource.

await waylay.resources.references('testresource')

// Response on resolve
{
 "values": [{...},{...}],
 "skip": 0,
 "limit": 100,
 "total": 2
}

Retrieves the referrer resources of the specified resource.

await waylay.resources.referrers('testresource', { skip: 0, limit: 100 })

// Response on resolve
{
 "values": [{...},{...},{...},{...},{...}],
 "skip": 0,
 "limit": 100,
 "total": 5
}

Update a resource, allows partial updates

await waylay.resources.update('testresource', {
exampleKey1: 'value1',
exampleKey2: 2,
exampleKey3: true
})

// Response on resolve
{
 "id": "testresource",
 "parentId": "Bearing_1",
 "name": "testresource",
 "exampleKey1": "value1",
 "exampleKey2": 2,
 "exampleKey3": true
}

Replace a resource, overwrites the existing resource.

await waylay.resources.replace('testresource', {
 exampleKey1: 'value1',
 exampleKey2: 2,
 exampleKey3: true
})

// Response on resolve
{
 "id": "testresource",
 "exampleKey1": "value1",
 "exampleKey2": 2,
 "exampleKey3": true
}

Remove a resource

await waylay.resources.remove('testresource')

Search for a resource matching the filter

See https://docs.waylay.io/#/api/resources/#query-resources for more information

await waylay.resources.search({
 filter: 'a',
 skip: 0,
 limit: 100
})

// Response on resolve
{
 "values": [{...},{...},{...},{...},{...},{...},{...},{...}],
 "skip": 0",
 "limit": 100,
 "total": 8
}

Executes a command defined on ResourceType / Resource level

await waylay.resources.executeCommand('testresource', 'testCommand')

// Response on resolve
{
  "message": "Published command for testresource",
  "content": {
   "name": "testCommand",
   "timestamp": 1616743972539
 }
}

This returns a paged list with the command logs.

See https://docs.waylay.io/#/api/resources/?id=retrieve-resource-command-log for more information

await waylay.resources.commandLogs('testresource', { skip: 0, limit: 10 })

// Response on resolve
{
 "values": [
  {
    "name": "testCommand",
    "executionTime": "2021-03-26T07:32:52.539Z",
    "errorMessage": "Resource 'testresource' not found"
  }
 ],
 "skip": 0,
 "limit": 10,
 "total": 1

}

Fetch resource history

See https://docs.waylay.io/#/api/resources/#retrieve-resource-change-log for more information

await waylay.resources.changelog('testresource', { skip: 0, limit: 10 })

// Response on resolve
{
"values": [
 {
   "time": "2021-03-25T09:56:46.193Z",
   "resourceId": "testresource",
   "userId": "292ffd11-231a-4b70-9457-e48e61018f21",
   "change": "updated",
   "resource": {
     "id": "testresource",
     "parentId": "testresourceParent",
     "name": "testresource",
     "testRef1": {
       "$ref": "/resources/testresourceParent"
     }
   }
 },{...},{...},{...},{...},{...},{...},{...},{...},{...}
],
"skip": 0,
"limit": 10,
"total": 21
}

Create a new resource type

See https://docs.waylay.io/#/api/rest/#create-resource-type

await waylay.types.create({ id: 'testType', test: 123 })

// Response on resolve
{
  "statusCode": 201,
  "uri": "/api/resourcetypes/testType",
  "entity": {
    "id": "testType",
    "name": "testType",
    "test": 123
    "$constraints": [],
    "$bulkOperation": "64c759ea-02cd-44da-a7ea-0d8f242872bb"
  }
}

Remove a resource type

await waylay.types.remove('testType')

Update a resource type Does not keep the existing metadata fields, use patch to do partial update

await waylay.types.update('testType', { name:'testType', test2: 456 })

// Response on resolve
{
  "id": "testType",
  "$constraints": [],
  "$bulkOperation": "be27101d-520e-4549-bfc6-6ec02ad07706",
  "test2": 456
}

Patch a resource

await waylay.types.patch('testType', { test3: 789 })

// Response on resolve
{
  "id": "testType",
  "$constraints": [],
  "$bulkOperation": "be27101d-520e-4549-bfc6-6ec02ad07706",
  "test2": 456,
  "test3": 789
}

list all resource types

await waylay.types.list({filter: "test"})

// Response on resolve
{
"values": [
  {
    "id": "testType",
    "$constraints": [],
    "test2": 456
  },{...},{...},{...},{...},{...},{...},{...},{...}
],
"skip": 0,
"limit": 100,
"total": 9
}

Get a specific resource type

await waylay.types.get('testType')

// Response on resolve
{
    "id": "testType",
    "$constraints": [],
    "test2": 456
}

Get the constraints of a specific resource type

await waylay.types.constraints('testType')

// Response on resolve
{
  "id": "merged",
  "name": "Constraints for resourceType 'ID: ResourceType(testType,None,None,None,None,None,None,None,Map(),Set(),None,Some({\"test2\":456})).id'",
  "description": "The reserved keywords as defined on docs as resource constraints",
  "attributes": [Array(16)]
}

Revalidate the constraints of a specific resource type

await waylay.types.revalidate('testType')

Fetch resource type history

See https://docs.waylay.io/#/api/rules/#retrieve-resource-type-change-log for more information

await waylay.types.changelog('testType', {limit: 25})

// Response on resolve
{
  "values": [
    {
      "time": "2021-03-31T08:29:26.182Z",
      "resourceTypeId": "testType",
      "userId": "292ffd11-231a-4b70-9457-e48e61018f21",
      "change": "updated",
      "resourceType": {
        "id": "testType",
        "$constraints": [],
        "test2": 456
      }
    },{...},{...},{...}
  ],
  "skip": 0,
  "limit": 25,
  "total": 4
}

list all resource constraints

Get a resource constraint by id

Add a resource constraint

Update a resource constraint

Remove a resource constraint

Create a new alarm

await waylay.alarms.create({
  type: 'TEST_ALARM',
  severity: 'MINOR',
  text: 'Alarm to test Node SDK',
  source: { id: 'testresource' }
})

// Response on resolve
{
 "id": "ab5dd822-734c-4db4-ae77-7ff1d5426413",
 "self": "/alarms/v1/alarms/ab5dd822-734c-4db4-ae77-7ff1d5426413",
 "creationTime": "2021-03-26T08:12:10.353149Z",
 "type": "TEST_ALARM",
 "text": "Alarm to test Node SDK",
 "timestamp": "2021-03-26T08:12:10.353115Z",
 "source": {
  "id": "testresource"
 },
 "severity": "MINOR",
 "status": "ACTIVE",
 "count": 1,
 "history": [
  {
    "id": "66208008-603c-46a6-84ba-82cd169cc20a",
    "type": "io.waylay.alarm.AlarmRaised",
    "text": "Alarm raised",
    "timestamp": "2021-03-26T08:12:10.353151Z"
  }
 ]
}

Get information about an alarm

await waylay.alarms.get('ab5dd822-734c-4db4-ae77-7ff1d5426413')

// Response on resolve
{
 "id": "ab5dd822-734c-4db4-ae77-7ff1d5426413",
 "self": "/alarms/v1/alarms/ab5dd822-734c-4db4-ae77-7ff1d5426413",
 "creationTime": "2021-03-26T08:12:10.353Z",
 "type": "TEST_ALARM",
 "text": "Alarm to test Node SDK",
 "timestamp": "2021-03-26T08:12:10.353Z",
 "source": {
   "id": "testresource"
 },
 "severity": "MINOR",
 "status": "ACTIVE",
 "count": 1,
 "history": [
   {
     "id": "66208008-603c-46a6-84ba-82cd169cc20a",
     "type": "io.waylay.alarm.AlarmRaised",
     "text": "Alarm raised",
     "timestamp": "2021-03-26T08:12:10.353151Z"
   }
 ]
}

Search for multiple alarms

See Query multiple alarms.

// Response on resolve
{
  "self": "/alarms/v1/alarms?severity=major&page=2&size=10",
  "alarms": [{...},{...}],
  "total": 12
  "prev": "/alarms/v1/alarms?severity=major&size=10"
}

Get the alarm history timeline for one or multiple resources, this is used to get a timeseries like array of alarms.

await waylay.alarms.timeline(['testresource'])

// Response on resolve
[
{
 "timestamp": 1616746330353,
 "type": "io.waylay.alarm.AlarmRaised"
 "Alarm": {...}
},
{...}
]

Update an alarm You can only update an ACTIVE or ACKNOWLEDGED alarm. Updating a CLEARED alarm will result in a response code 412 Precondition Failed

await waylay.alarms.update('56fa5a52-a02c-4551-93ac-197b13fe36db', { severity: 'WARNING', status: 'ACKNOWLEDGED'})

{
"id": "56fa5a52-a02c-4551-93ac-197b13fe36db",
"self": "/alarms/v1/alarms/56fa5a52-a02c-4551-93ac-197b13fe36db",
"creationTime": "2021-03-26T09:15:58.474Z",
"type": "TEST_ALARM",
"text": "Alarm to test Node SDK",
"timestamp": "2021-03-26T09:15:58.474Z",
"source": {
  "id": "testresource"
},
"severity": "WARNING",
"status": "ACKNOWLEDGED",
"count": 1,
"history": [
  {
    "id": "4fdb9180-04ad-498f-a4f5-6e2b7213f04b",
    "type": "io.waylay.alarm.AlarmRaised",
    "text": "Alarm raised",
    "timestamp": "2021-03-26T09:15:58.474282Z"
  },
  {
    "id": "5ba38c0f-8e54-4e32-b7d2-6d6a192dbc06",
    "type": "io.waylay.alarm.AlarmUpdated",
   "text": "Alarm updated",
   "timestamp": "2021-03-26T09:17:05.954729Z",
   "changes": [
     {
       "attribute": "severity",
       "type": "io.waylay.alarm.change.severity",
       "oldValue": "MINOR",
       "newValue": "WARNING"
     },
     {
       "attribute": "status",
       "type": "io.waylay.alarm.change.status",
       "oldValue": "ACTIVE",
       "newValue": "ACKNOWLEDGED"
    }
  ]
}
]}

Remove an alarm

await waylay.alarms.remove('56fa5a52-a02c-4551-93ac-197b13fe36db')

Remove all alarms matching a filter

See Query multiple alarms.

await waylay.alarms.remove({ type: 'TEST_ALARM' })

Create a new task

See https://docs.waylay.io/#/api/rules/#create-a-task

Update a task

See https://docs.waylay.io/#/api/rules/#update-a-task

List all tasks with optional filter

See https://docs.waylay.io/#/api/rules/#query-multiple-tasks

Count tasks

Remove a task, will fail if task is still running

Remove multiple tasks, will fail if a task is still running

Retrieve details of a task

Start a task that is not in a running state

Stop a task that is in a running state

Stop a task and remove it

Fetch logs for a task

Build task logs URL based on given search params

Build task events URL

Push state to a node on a task

Patch state and rawdata for a node on a task

Create a new template

See https://docs.waylay.io/#/api/rules/#create-a-new-template

Update an existing template

See https://docs.waylay.io/#/api/rules/#update-a-template

List all templates with optional filter

See https://docs.waylay.io/#/api/rules/#list-all-templates

Retrieve details of a template

Remove a template

Get all variables used in a template

Get declarative bindings available for usage in a template

Retrieve the current discovery template for this tenant.

Set the discoveryTemplate for this tenant.

Perform a patch operation on one or more templates

Execute one individual plug

See https://docs.waylay.io/#/api/rules/#execute-plug

Execute a given script as a plug.

List your plugs

Get details of one individual plug

Create a new plug

Remove all versions of a plug

Remove specific plug version

// Deprecate specific plug version
await waylay.sensors.removeVersion({
  name: 'MySensor',
  version: '1.0.0'
})

// Response
{ statusCode: 200, message: 'Sensor MySensor 1.0.0 deprecated' }

// Delete specific plug version
await waylay.sensors.removeVersion({
  name: 'MySensor',
  version: '1.0.0',
  { force: true }
})

// Response
{ statusCode: 200, message: 'Sensor MySensor 1.0.0 deleted' }

Get the script of a plug

Get all versions of a plug

Updates the metadata of a plug

Updates the metadata of a plug

List plug tags by plug tag options

Get plug tag by plug name

Get all converters

Get a converter by name

Create a converter

Update an existing converter

Delete an existing converter

Convert a payload using an existing converter. Requires NodeJS runtime

Test a payload conversion without saving a converter. Requires NodeJS runtime

Send data to a webscript

waylay.webscripts.call('d15a29d7-4290-4bfa-aceb-d3f2e791737c', 'my-webscript', 'latest', { key: 'value' }, {headers : { key : 'value' } })
  .then(response => console.log(response))
  .catch(err => console.error(error))

// calls a webscript with  GET method and url params (`GET .../my-webscript?includeDetails=true`)
const resp = waylay.webscripts.call('d15a29d7-4290-4bfa-aceb-d3f2e791737c', 'my-webscript', undefined,  undefined, { method: 'GET', params: { includeDetails: true }})

List your webscripts

Checks if webscript exists

Get details of one individual webscript

Create a new webscript

Remove a webscript

Update a webscript - updates are atomic

Retrieve logs from a webscript

Executes operation on webscript

Get webscript trigger URL

Get version

List your models

Get information about a model

Get an example predict payload for a model

Infer predictions from a model See https://docs.waylay.io/#/api/byoml/?id=predictions

Infer predictions from a model using regression

Infer predictions from a model using classification

Remove a model

Patch model metadata (such as description) that can be modified without redeploying the model.

Execute a named (or given) query (doc).

List stored query definitions. (doc)

Fetch the definition of a stored query. (doc)

Create a new stored query. (doc)

Update an existing stored query. (doc)

Remove a stored query.

Storage API methods on a bucket.

Extends Resource

Storage API methods on a file object.

Extends Resource

const signResp = await waylay.storage.object.signGet('assets', 'abc.json')
const resp = await fetch(signResp._links.get_object.href)
const myAbcData = resp.json()

const signResp = await waylay.storage.object.signPost('assets', 'abc.txt')
const postUrl = signResp._links.post_object.href
const formData = signResp._links.post_object.form_data
formData['content-type'] = 'text/plain'
const postForm = new FormData(formData)

// file is input of a <input type="file"> form
postForm.append('file', file)
const postResp = await fetch(postUrl, {
   method: 'POST',
   body: postForm
})
window.alert(postResp.ok ? 'File upload done', 'File upload failed')