# socketvat

> eventvat + nssocket

Latest version **0.0.27** (published 2013-12-01) · 0 weekly downloads

## Install

```sh
npm install socketvat
pnpm add socketvat
yarn add socketvat
bun add socketvat
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.0.27 |
| Published | 2013-12-01 |
| First published | 2012-02-25 |
| Weekly downloads | 0 |
| TypeScript types | none |
| Module format | CommonJS |
| Node | * |
| Dependencies | 4 |
| Known vulnerabilities | 0 (+2 in 1 direct dependencies) |
| Install scripts | no |
| GitHub stars | 3 |
| Maintainers | guybrush |

## Links

- npm: https://www.npmjs.com/package/socketvat
- Repository: https://github.com/guybrush/socketvat
- Issues: https://github.com/guybrush/socketvat/issues
- npm.io page: https://npm.io/package/socketvat

## Dependencies (4)

- [debug](https://npm.io/package/debug.md) 0.5.0
- [eventvat](https://npm.io/package/eventvat.md) 0.2.1
- [nssocket](https://npm.io/package/nssocket.md) 0.5.1
- [eventemitter2](https://npm.io/package/eventemitter2.md) 0.4.8

## Recent versions

- 0.0.27 (latest) — 2013-12-01
- 0.0.26 — 2013-08-20
- 0.0.25 — 2013-08-14
- 0.0.24 — 2012-10-31
- 0.0.23 — 2012-06-30
- 0.0.22 — 2012-06-21
- 0.0.21 — 2012-06-21
- 0.0.20 — 2012-06-18
- 0.0.19 — 2012-06-15
- 0.0.18 — 2012-06-15
- 0.0.17 — 2012-06-15
- 0.0.16 — 2012-06-15
- 0.0.15 — 2012-06-14
- 0.0.14 — 2012-03-29
- 0.0.13 — 2012-03-14
- … 12 more at https://npm.io/package/socketvat/versions

## README

# socketvat

[EventVat] + [nssocket]

[EventVat]: https://github.com/hij1nx/EventVat
[nssocket]: https://github.com/nodejitsu/nssocket

## install

* install node
* `npm install socketvat`
* `npm test socketvat`
* `DEBUG=socketvat,test npm test socketvat`

## api

### sv = socketvat(`opts`)

* `instanceof sv === require('eventvat')`
* `opts.namespace` - default: `socketvat` - will be used to prefix every event
  which will be sent to remote socket, also it will only listen for remote 
  events prefixed by that namespace

### sv.initSocket(`<socket>`[,`<cb>`])

`<socket>` has to be an instance of `require('nssocket').NsSocket`

```
var nss = require('nssocket')
var sv = require('socketvat')
var serverVat = sv()
var clientVat = sv()
var s = nss.createServer(function(s){serverVat.initSocket(s)})
s.listen(4545)
var c = new nss.NsSocket()
clientVat.initSocket(c)
c.connect(4545)
```
  
### sv.listen(`<arg1>`[,`<arg2>`[,`<arg3>`]],[`<listener>`])

this will start a `net` or `tls`-Server

* `<arg1>`, `<arg2>`, `<arg3>`
    * `Int` → `port`
    * `String` → `host` (or `path` if no port is defined, start a 
      unix-socket-server)
    * `Object`
        * `port` → `port`
        * `host` → `host`
        * `key` → start `tls`-Server with that key
        * `cert` → start `tls`-Server with that cert
        * `ca` → start `tls`-Server with that ca
        
* `<listener>`
    * `Function` → connection-listener, will be called with 2 arguments:
        * a object with helper-functions for communication with remote socketvat
        * an instance of `require('nssocket').NsSocket`

### sv.connect(`<arg1>`[,`<arg2>`[,`<arg3>`]],[`<listener>`])

this will create a `net` or `tls`-Connection

* `<arg1>`, `<arg2>`, `<arg3>`
    * `Int` → `port`
    * `String` → `host` (or `path` if no port is defined, start a 
      unix-socket-connection)
    * `Object`
        * `port` → `port`
        * `host` → `host`
        * `key` → start `tls`-Connection with that key
        * `cert` → start `tls`-Connection with that cert
        * `reconnect` → upon connection -drop or -error, connect again in 
          `opts.reconnect` milliseconds
        
* `<listener>`
    * `Function` → connection-listener, will be called with 2 arguments:
        * a object with helper-functions for communication with remote socketvat
        * an instance of `require('nssocket').NsSocket`
        
## examples
        
### simple

```
var sv = require('../socketvat')
var assert = require('assert')
// server
var s = sv()
s.set('foo','server')
s.listen(3000,function(remote,socket){
  remote.once('get',function(k,v){
    assert.equal(k,'foo')
    assert.equal(v,'client')
  })
  remote.get('foo')
})
// client
var c = sv()
c.set('foo','client')
c.connect(3000,function(remote,socket){
  remote.once('get',function(k,v){
    assert.equal(k,'foo')
    assert.equal(v,'server')
  })
  remote.get('foo')
})
```

### verbose

``` javascript
var sv = require('../socketvat')

var serverVat = sv()
var server = serverVat.listen(3000,function(r,s){
  r.onAny(ee2log('serverRemote'))
  s.onAny(ee2log('serverSocket'))
  s.on('error',function(err){console.log('socket error',err)})
  s.on('close',function(){
    console.log('---- client disconnected')
    server.close()
    process.exit()
  })
  r.set('server','x')
})

var clientVat = sv()
var client = clientVat.connect(3000,function(r,s){
  r.onAny(ee2log('clientRemote'))
  s.onAny(ee2log('clientSocket'))
  r.set('client','y',function(err){console.log('---- sent the message')})
  r.get('client')
  r.keys('client')
  setTimeout(function(){s.end()},100)
})

serverVat.on('**',ee2log('serverVat'))
serverVat.once('set client',function(){
  console.log('---- serverVat once "set client":',this.event,'→',[].slice.call(arguments))
})

clientVat.on('**',ee2log('clientVat'))
clientVat.once('set *',function(){
  console.log('---- clientVat once "set *":',this.event,'→',[].slice.call(arguments))
})

serverVat.set('foo','bar')
clientVat.set('foo','bar')

function ee2log(name){return function(){
  name = name || '•'
  name = name+Array(13).slice(name.length).join(' ')
  var event = Array.isArray(this.event) ? this.event.join(' ') : this.event
  event = event+Array(32).slice(event.length).join(' ')
  console.log(name,':',event,'→',[].slice.call(arguments))
}}
```

output:

```
serverVat    : set foo                         → [ 'bar' ]
serverVat    : set                             → [ 'foo', 'bar' ]
---- clientVat once "set *": set foo → [ 'bar' ]
clientVat    : set foo                         → [ 'bar' ]
clientVat    : set                             → [ 'foo', 'bar' ]
clientSocket : start                           → []
---- sent the message
serverSocket : start                           → []
serverSocket : data socketvat method onAny     → [ { args: [] } ]
serverSocket : data socketvat method set       → [ { args: [ 'client', 'y' ] } ]
---- serverVat once "set client": set client → [ 'y' ]
serverVat    : set client                      → [ 'y' ]
serverVat    : set                             → [ 'client', 'y' ]
serverSocket : data socketvat method get       → [ { args: [ 'client' ] } ]
serverVat    : get client                      → [ 'y' ]
serverVat    : get                             → [ 'client', 'y' ]
serverSocket : data socketvat method keys      → [ { args: [ 'client' ] } ]
serverVat    : keys                            → [ /client/, [ 'client' ] ]
clientSocket : data socketvat method onAny     → [ { args: [] } ]
clientSocket : data socketvat method set       → [ { args: [ 'server', 'x' ] } ]
clientVat    : set server                      → [ 'x' ]
clientVat    : set                             → [ 'server', 'x' ]
clientSocket : data socketvat event set client → [ { args: [ 'y' ] } ]
clientRemote : set client                      → [ 'y' ]
clientSocket : data socketvat event set        → [ { args: [ 'client', 'y' ] } ]
clientRemote : set                             → [ 'client', 'y' ]
clientSocket : data socketvat event get client → [ { args: [ 'y' ] } ]
clientRemote : get client                      → [ 'y' ]
clientSocket : data socketvat event get        → [ { args: [ 'client', 'y' ] } ]
clientRemote : get                             → [ 'client', 'y' ]
clientSocket : data socketvat event keys       → [ { args: [ 'client', [Object] ] } ]
clientRemote : keys                            → [ 'client', [ 'client' ] ]
serverSocket : data socketvat event set server → [ { args: [ 'x' ] } ]
serverRemote : set server                      → [ 'x' ]
serverSocket : data socketvat event set        → [ { args: [ 'server', 'x' ] } ]
serverRemote : set                             → [ 'server', 'x' ]
clientSocket : close                           → [ undefined ]
serverSocket : close                           → []
---- client disconnected
```

---
_Source: https://npm.io/package/socketvat · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._
