littlebits-cloud-http v0.3.4

cloud-api-http-client

Lightweight wrapper for littleBits Cloud HTTP API

Installation

npm install --save littlebits-cloud-http

Example

var api = require('littlebits-cloud-http')
          .defaults({ access_token: 'askdjfldaksjfkdlsjfdkl234324' })
// We've created a new instance of our api with an access_token to be used by all requests.

api = api.defaults({ device_id: 'foobar' })
// All api functions will now default to using device_id
// 'foobar' for those abstracting HTTP endpoints that use
// the {device_id} path-param (e.g. /devices/{device_id}/output).

api.output()
// -> <err> <result>
// Neat; By default functions log to console
// which is great for playing around.

api.output('foobar2')
// The device_id can also be specified as the
// first argument (overriding defaults, not mutating),
// allowing the second argument to focus on
// your payload...

api.output('foobar2', { percent: 50, duration_ms: 5000 })
// like so :). Of course you can work with objects only
// as needed/desired...

api.output({device_id: 'foobar2', percent: 50, duration_ms: 5000 })
// Hm, these arguments are getting repetitive, lets stop this.

var output = api.output.defaults({device_id: 'foobar2', percent: 50, duration_ms: 5000 })
// Better. Now we have a output function with new defaults.
// and we can always call .defaults again should we wish.
// Lets use it now.

output(function(err, result){
  if (err) ...

  ...
});
// Pass your own callback to handle the
// the io error and/or return value. This of course
// elliminates the default logging seen above.



// Helpful notes about .defaults()

// 1. it does not mutate
//   - .defaults() on the api object returns an entirely new api
//   - .defaults() on a function returns an entirely new function
assert api.defaults({...}) !== api

// 2. it is infinitly recrusive so this is possible (but psychotic)
api.defaults({...}).defaults({...})/* ad infinitum*/.output.defaults({...}).defaults({...}) /* ad infinitum */

// 3. defaults can be introspected by passing no arguments, e.g. given a stock api instnace
api.defaults()
// -> { host: 'https://api-http.littlebitscloud.cc', version: '2' }



// Fin.

// You've seen several different function signatures.
// They are at your disposal to choose as desired.
// See API docs for more details and Have fun!

API Functions

Abbreviated information. See API Function Signatures for details about the argument pattern uniformly accepted.

.defaults()

See Defaults System.

Key Points:

• Supports snake_case or camelCase key names
• Returns new instances, does not mutate existing defaults
• Returns current defaults if invoked with no arguments

.devices()

Get information for all devices.

callback result argument: [Device]

.device()

Get information for one device.

options arguments

• device_id :: String

callback result argument: Device

.activate()

Activate one device. (FYI: associates device to user; User id is attained from the provided access_token)

options arguments

• device_id :: String

callback result argument: Device

.deactivate()

Dectivate one device.

options arguments

• device_id :: String

callback result argument: Device

.output()

Send amplitude out of the device.

options arguments:

• percent :: Float | >= 0, <= 100
• duration_ms :: Integer | >= 0
• device_id :: String

callback result argument: TODO

.light()

Activate device light.

options arguments:

• color :: String | "green" "yellow" "red" "blue" "purple" "white" "cyan" "clownbarf"
• mode :: String | "blink" "hold"
• duration_ms :: Integer | >= 0
• device_id :: String

callback result argument: TODO

.subscriptions()

Get the subscriptions for given sub/pub.

options arguments:

• ? subscriber_id :: device_id || uri
  Filter subscriptions to those where subscriber_id matches.
• ? publisher_id :: device_id
  Filter subscriptions to those where publisher_id matches.

callback result argument: [Subscription]

.unsubscribe()

Delete the subscription for given sub/pub.

options arguments:

• subscriber_id :: device_id || uri
• publisher_id :: device_id

callback result argument: TODO

.subscribe()

Create a new subscription for given sub/pub.

options arguments:

• subscriber_id :: device_id || uri
• publisher_id :: device_id
• ? publisher_events :: [Event]
  Defaults to: ["amplitude:delta:ignite"]

callback result argument: TODO

Types

Event

A String of any following value:

"amplitude"
"amplitude:delta:sustain"
"amplitude:delta:ignite"
"amplitude:delta:release"
"amplitude:delta:nap"
"amplitude:level:active"
"amplitude:level:idle"

Subscription

{
  subscriber_id    :: device_id || URI
  publisher_id     :: device_id
  publisher_events :: [Event]
}

Device

{
  id            :: String
  user_id       :: Integer
  label         :: String
  subscribers   :: [Subscription]
  subscriptions :: [Subscription]
}

API Function Signatures

All API functions (except .defaults) are variadic-polymorphic, following these defintions.

Arity 0

f :: -> void

e.g.:

api.output()

Arity 1

f :: (err, * -> void) -> void

f :: ID -> void

f :: Options -> void

e.g.:

api.output(function(err, result){ /*...*/ })
api.output('foobar-device-id')
api.output({ device_id: 'foobar-device-id', duration_ms: 500 })

Arity 2

f :: ID, (err, * -> void) -> void

f :: Options, (err, * -> void) -> void

f :: ID, Options -> void

e.g.:

api.output('foobar-device-id', function(err, result){ /*...*/ })
api.output({ device_id: 'foobar-device-id', duration_ms: 500 }, function(err, result){ /*...*/ })
api.output('foobar-device-id', { duration_ms: 500 })

Arity 3

f :: ID, Options, (err, * -> void) -> void

e.g.:

api.output('foobar-device-id', { duration_ms: 500 }, function(err, result){ /*...*/ })

For all arity cases:

• Options arguments that you omit are patched by defaults. You may customize defaults (see next section).

• ID refers to device_id which can alternatively be argued in Options as device_id. Certain functions do not need a device_id, such as subscribe in which case it is useless (but harmless), to argue this.

• callback is patched by console.log. This is useful for rapid manual tests, playing around, etc. It also helps keep track of unhandled callbacks which you should be handling in non-trivial work. If you really want a noop then just argue one.

Defaults system

.defaults()

get

defaults :: -> Options

Get the current defaults.

set

defaults :: Options -> API

Create a new api with new defaults. Existing api instance is not mutated. All functions of new api instance will read from these new defaults.

This is a good place to argue access_token etc.

options arguments:

• ? host :: URI
  The HTTP server to make requests against. By default equals 'api-http.littlebitscloud.cc' but you may override as desired, e.g. work against local development servers.
• ? version :: String
  The littleBits Cloud HTTP API version to use. By default equals '2'.
• ? access_token :: String
  The OAuth access_token that will be used by the server to authorize your requsts.

.{api_function}.defaults()

get

defaults :: -> Options

Get the current defaults.

set

defaults :: Options -> API_Function

Create a new api function (f) with new defaults. Existing f is not mutated.

options arguments: See docs for each function respectively.