Socket
Socket
Sign inDemoInstall

twilio-notifications

Package Overview
Dependencies
Maintainers
2
Versions
53
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

twilio-notifications - npm Package Compare versions

Comparing version 0.4.4 to 0.5.0

browser/client.js
browser/configuration.js
browser/connector.js
browser/index.js
browser/logger.js
browser/registrar.connector.js
browser/registrar.js
browser/twilsock.connector.js
lib/client.d.ts
lib/configuration.d.ts
lib/connector.d.ts
lib/connector.js
lib/index.d.ts
lib/logger.d.ts
lib/registrar.connector.d.ts
lib/registrar.d.ts
lib/twilsock.connector.d.ts
tsconfig.json
tslint.json

26

examples/gcm/manifest.json

@@ -1,14 +0,16 @@

{
"name": "Twilio GCM receiver",
"short_name": "GCM Receiver",
"icons": [{
"src": "images/icon-192x192.png",
"sizes": "192x192",
"type": "image/png"
}],
"start_url": "./index.html",
"display": "standalone",
"gcm_sender_id": "298461450745",
"gcm_user_visible_only": true
{
"name": "Twilio GCM receiver",
"short_name": "GCM Receiver",
"icons": [
{
"src": "images/icon-192x192.png",
"sizes": "192x192",
"type": "image/png"
}
],
"start_url": "./index.html",
"display": "standalone",
"gcm_sender_id": "298461450745",
"gcm_user_visible_only": true
}

45

examples/gcm/service-worker.js

@@ -1,5 +0,4 @@

self.oninstall = function (e) {
// populate cache
// download all resources needed for offline experience
// populate cache
// download all resources needed for offline experience

@@ -9,3 +8,3 @@ }

self.onactivate = function (e) {
// cleanup like managing cache
// cleanup like managing cache

@@ -15,29 +14,29 @@ var title = 'Worker activated!';

self.registration.showNotification(title, {
body: body,
icon: '',
tag: 'tag'
})
self.registration.showNotification(title, {
body: body,
icon: '',
tag: 'tag'
})
}
self.onfetch = function (e) {
// deal with network traffic
// deal with network traffic
}
self.addEventListener('push', function(event) {
console.log('Received a push message', event);
self.addEventListener('push', function (event) {
console.log('Received a push message', event);
var title = 'Yay a message.';
var body = 'We have received a push message.';
var icon = '/images/icon-192x192.png';
var tag = 'simple-push-demo-notification-tag';
var title = 'Yay a message.';
var body = 'We have received a push message.';
var icon = '/images/icon-192x192.png';
var tag = 'simple-push-demo-notification-tag';
event.waitUntil(
self.registration.showNotification(title, {
body: body,
icon: icon,
tag: tag
})
);
event.waitUntil(
self.registration.showNotification(title, {
body: body,
icon: icon,
tag: tag
})
);
});

335

gulpfile.js
const gulp = require('gulp');
const gutil = require('gulp-util');
const mocha = require('gulp-mocha');
const istanbul = require('gulp-istanbul');
const eslint = require('gulp-eslint');
const tslint = require('gulp-tslint');
const browserify = require('browserify');
const babelify = require('babelify');
const babel = require('babel-core/register');
const babel = require('gulp-babel');
const source = require('vinyl-source-stream');

@@ -17,3 +16,4 @@ const buffer = require('vinyl-buffer');

const rename = require('gulp-rename');
const uglify = require('gulp-uglify');
const uglify = require('gulp-uglify-es').default;
const uglifySaveLicense = require('uglify-save-license');
const cheerio = require('cheerio');

@@ -23,197 +23,223 @@ const tap = require('gulp-tap');

const isparta = require('isparta');
const typescript = require('gulp-typescript');
const path = require('path');
const pkg = require('./package');
var cp = require('child_process');
var jsdoc = 'node_modules/jsdoc/jsdoc.js';
const cp = require('child_process');
const jsdoc = 'node_modules/jsdoc/jsdoc.js';
const product = {
source: {
name: pkg.name + '.js',
lib: 'src/*.js'
},
packaged: {
dir: 'dist',
name: pkg.name + '.js',
minified: pkg.name + '.min.js'
},
bundled: {
dir: 'build',
name: pkg.name + '-bundle.js'
},
license: 'LICENSE'
source: {
name: pkg.name + '.ts',
lib: 'src/**/*.ts'
},
compiled: {
dir: 'lib',
lib: 'lib/**/*.js'
},
browser: {
dir: 'browser'
},
packaged: {
dir: 'dist',
name: pkg.name + '.js',
minified: pkg.name + '.min.js'
},
bundled: {
dir: 'build',
name: pkg.name + '-bundle.js'
},
license: 'LICENSE'
};
const tests = {
lint: {
files: [
'src/*.js',
'!src/utils.js',
'!src/jsondiff.js',
'gulpfile.js'
]
},
unit: {
files: 'test/unit/spec/*.js',
index: 'test/unit/index.js'
},
integration: {
files: 'test/integration/**/*.js',
index: 'test/integration/index.js'
}
lint: {
files: [
'src/*.ts',
'!gulpfile.js'
]
},
unit: {
files: 'test/unit/spec/*.ts',
index: 'test/unit/index.ts'
},
integration: {
files: 'test/integration/**/*.ts',
index: 'test/integration/index.ts'
}
};
const coverage = {
dir: product.packaged.dir + '/coverage'
dir: product.packaged.dir + '/coverage'
};
const docs = {
dir: product.packaged.dir + '/docs',
conf: 'jsdoc.json',
files: [
'./src/client.js'
],
publicConstructors: ['Client'],
privateConstructors: []
dir: product.packaged.dir + '/docs',
conf: 'jsdoc.json',
files: [
'./lib/client.js'
],
publicConstructors: ['Client'],
privateConstructors: []
};
gulp.task('lint', function() {
return gulp.src(tests.lint.files)
.pipe(eslint())
.pipe(eslint.format())
.pipe(eslint.failAfterError());
return gulp
.src(tests.lint.files)
.pipe(tslint({
formatter: 'prose'
}))
.pipe(tslint.report({
allowWarnings: false,
emitError: true,
summarizeFailureOutput: true
}));
});
gulp.task('istanbul-setup', function() {
return gulp.src([product.source.lib])
.pipe(istanbul({
instrumenter: isparta.Instrumenter,
includeUntested: true
}))
.pipe(istanbul.hookRequire());
return gulp.src([product.source.lib])
.pipe(istanbul({
instrumenter: isparta.Instrumenter,
includeUntested: true
}))
.pipe(istanbul.hookRequire());
});
gulp.task('unit-test', ['istanbul-setup'], function() {
return gulp.src(tests.unit.index, { read: false })
.pipe(mocha({
compilers: { js: babel },
reporter: 'spec'
}))
.pipe(istanbul.writeReports({
dir: coverage.dir,
reporters: ['cobertura', 'lcov', 'text'],
reportOpts: { dir: coverage.dir }
}));
gulp.task('unit-test', function() {
return gulp.src(tests.unit.index, { read: false })
.pipe(mocha({
require: 'ts-node/register',
reporter: 'spec',
exit: true,
suppress: false
}));
// .pipe(istanbul.writeReports({
// dir: coverage.dir,
// reporters: ['cobertura', 'lcov', 'text'],
// reportOpts: { dir: coverage.dir }
// }));
});
gulp.task('integration-test', function() {
return gulp.src(tests.integration.index, { read: false })
.pipe(mocha({ reporter: 'spec', timeout: 5000 }))
.pipe(exit());
return gulp.src(tests.integration.index, { read: false })
.pipe(mocha({
require: 'ts-node/register',
reporter: 'spec',
exit: true,
suppress: true,
timeout: 5000
}));
});
gulp.task('bundle', function(done) {
browserify({ debug: false, standalone: 'Twilio.Notification.Client', entries: ['./src/index.js'] })
.exclude('ws')
.transform(babelify, {
global: true,
ignore: /\/node_modules\/(?!twilio-transport|twilsock\/)/
})
.bundle()
.pipe(source(product.bundled.name))
.pipe(buffer())
.pipe(derequire())
.pipe(gulp.dest(product.bundled.dir))
.once('end', done)
.once('error', exit);
gulp.task('build-node', function() {
const project = typescript.createProject('tsconfig.json');
return project.src()
.pipe(project())
.once("error", function() { this.once("finish", () => process.exit(1)); })
.pipe(gulp.dest('lib'));
});
gulp.task('license', function() {
var licenseContents = fs.readFileSync(product.license);
return gulp.src(product.bundled.dir + '/' + product.bundled.name)
.pipe(insert.prepend(
'/* ' + pkg.name + '.js ' + pkg.version + '\n'
+ licenseContents
+ '*/\n\n'
))
.pipe(rename(product.packaged.name))
.pipe(gulp.dest(product.packaged.dir));
gulp.task('build-browser', function() {
return gulp.src(product.compiled.lib)
.pipe(babel())
.pipe(gulp.dest('browser'));
});
gulp.task('minify', function() {
return gulp.src(product.packaged.dir + '/' + product.packaged.name)
.pipe(uglify({
output: {
ascii_only: true // eslint-disable-line camelcase
},
preserveComments: 'license'
}).on('error', gutil.log))
.pipe(rename(product.packaged.minified))
.pipe(gulp.dest(product.packaged.dir));
});
gulp.task('bundle', function() {
const licenseContents = fs.readFileSync(product.license);
return browserify({
debug: false,
standalone: 'Twilio.Notifications',
entries: ['./lib/client.js']
})
.transform(babelify)
.bundle()
.pipe(source(product.packaged.name))
.pipe(buffer())
.pipe(derequire())
.pipe(insert.prepend(`/* ${pkg.name}.js ${pkg.version}\n${licenseContents}*/\n\n`))
.pipe(gulp.dest(product.packaged.dir));
gulp.task('build', function(done) {
runSequence('bundle', 'license', done);
});
gulp.task('package', function(done) {
runSequence('minify', done);
gulp.task('minify', function() {
return gulp
.src(path.join(product.packaged.dir, product.packaged.name))
.pipe(uglify({
output: {
ascii_only: true, comments: uglifySaveLicense
}
}))
.once("error", function (err) {
console.error('Failed to minify', err.cause);
this.once("finish", () => process.exit(1));
})
.pipe(rename(product.packaged.minified))
.pipe(gulp.dest(product.packaged.dir));
});
gulp.task('generate-doc', function(cb) {
cp.exec(['node', jsdoc,
'-d', docs.dir,
'-c', docs.conf,
docs.files.join(' '),
'./README.md',
'-t ./node_modules/ink-docstrap/template'].join(' '), cb);
gulp.task('package', gulp.series(
'build-node',
'bundle',
'minify'));
gulp.task('build', gulp.series(
'lint',
'build-node',
'build-browser',
'package'));
gulp.task('generate-doc', function (cb) {
cp.exec(['node', jsdoc,
'-d', docs.dir,
'-c', docs.conf,
docs.files.join(' '),
'./README.md',
'-t ./node_modules/ink-docstrap/template'].join(' '), cb);
});
gulp.task('prettify-doc', function() {
return gulp.src(docs.dir + '/*.html')
.pipe(tap(function(file) {
var $ = cheerio.load(file.contents.toString());
var filename = file.path.slice(file.base.length);
var className = filename.split('.html')[0];
var div;
return gulp.src(docs.dir + '/*.html')
.pipe(tap(function (file) {
let $ = cheerio.load(file.contents.toString());
let filename = file.path.slice(file.base.length);
let className = filename.split('.html')[0];
let div;
// Prefix public constructors.
if (docs.publicConstructors.indexOf(className) > -1) {
div = $('.container-overview');
var name = $('h4.name', div);
name.html(name.html().replace(/new /, 'new <span style="color: #999">Twilio.Notification.</span>'));
}
// Prefix public constructors.
if (docs.publicConstructors.indexOf(className) > -1) {
div = $('.container-overview');
let name = $('h4.name', div);
name.html(name.html().replace(/new /, 'new <span style="color: #999">Twilio.Notifications.</span>'));
}
// Remove private constructors.
if (docs.privateConstructors.indexOf(className) > -1) {
div = $('.container-overview');
$('h2', div).remove();
$('h4.name', div).remove();
$('div.description', div).remove();
$('h5:contains(Parameters:)', div).remove();
$('table.params', div).remove();
}
// Remove private constructors.
if (docs.privateConstructors.indexOf(className) > -1) {
div = $('.container-overview');
$('h2', div).remove();
$('h4.name', div).remove();
$('div.description', div).remove();
$('h5:contains(Parameters:)', div).remove();
$('table.params', div).remove();
}
file.contents = new Buffer($.html());
return file;
}))
.pipe(gulp.dest(docs.dir));
file.contents = new Buffer($.html());
return file;
}))
.pipe(gulp.dest(docs.dir));
});
gulp.task('doc', function(done) {
runSequence('generate-doc', 'prettify-doc', done);
});
gulp.task('doc', gulp.series(
'generate-doc',
'prettify-doc'));
gulp.task('clean', function() {
return del([
product.packaged.dir + '/' + product.packaged.name,
product.packaged.dir + '/' + product.packaged.minified,
docs.dir,
product.bundled.dir + '/' + product.bundled.name
]);
});
gulp.task('clean', () => del([
product.compiled.dir,
product.browser.dir,
product.packaged.dir,
]));
gulp.task('default', function(done) {
runSequence(
gulp.task('default', gulp.series(
'clean',

@@ -224,6 +250,3 @@ 'lint',

'package',
'doc',
done
);
});
'doc'));

10

jsdoc.json
{
"tags": {
"allowUnknownTags": true,
"dictionaries": ["jsdoc", "closure"]
"dictionaries": [
"jsdoc",
"closure"
]
},

@@ -11,3 +14,6 @@ "source": {

"babel": {
"extensions": ["js", "es6"]
"extensions": [
"js",
"es6"
]
},

@@ -14,0 +20,0 @@ "templates": {

398

lib/client.js

@@ -1,77 +0,8 @@

'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _promise = require('babel-runtime/core-js/promise');
var _promise2 = _interopRequireDefault(_promise);
var _defineProperties = require('babel-runtime/core-js/object/define-properties');
var _defineProperties2 = _interopRequireDefault(_defineProperties);
var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
var _createClass2 = require('babel-runtime/helpers/createClass');
var _createClass3 = _interopRequireDefault(_createClass2);
var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
var _inherits2 = require('babel-runtime/helpers/inherits');
var _inherits3 = _interopRequireDefault(_inherits2);
var _configuration = require('./configuration');
var _configuration2 = _interopRequireDefault(_configuration);
var _events = require('events');
var _events2 = _interopRequireDefault(_events);
var _logger = require('./logger');
var _logger2 = _interopRequireDefault(_logger);
var _bottleneck = require('bottleneck');
var _bottleneck2 = _interopRequireDefault(_bottleneck);
var _registrar = require('./registrar');
var _registrar2 = _interopRequireDefault(_registrar);
var _twilsock = require('twilsock');
var _twilsock2 = _interopRequireDefault(_twilsock);
var _twilioTransport = require('twilio-transport');
var _twilioTransport2 = _interopRequireDefault(_twilioTransport);
var _twilioEmsClient = require('twilio-ems-client');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function limit(fn, to, per) {
// overflow since no token is passed to arguments
var limiter = new _bottleneck2.default(to, per, 1, _bottleneck2.default.strategy.LEAK);
return function () {
var args = Array.prototype.slice.call(arguments, 0);
args.unshift(fn);
return limiter.schedule.apply(limiter, args);
};
}
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const twilsock_1 = require("twilsock");
const configuration_1 = require("./configuration");
const registrar_1 = require("./registrar");
const logger_1 = require("./logger");
/**

@@ -88,145 +19,96 @@ * @class

*/
var Client = function (_EventEmitter) {
(0, _inherits3.default)(Client, _EventEmitter);
function Client(fpaToken, options) {
(0, _classCallCheck3.default)(this, Client);
var _this = (0, _possibleConstructorReturn3.default)(this, (Client.__proto__ || (0, _getPrototypeOf2.default)(Client)).call(this));
if (!fpaToken) {
throw new Error('Token is required for Notifications client');
class Client extends events_1.EventEmitter {
constructor(token, options = {}) {
super();
if (!token || token.length === 0) {
throw new Error('Token is required for Notifications client');
}
options.logLevel = options.logLevel || 'error';
logger_1.log.setLevel(options.logLevel);
const minTokenRefreshInterval = options.minTokenRefreshInterval || 10000;
const productId = options.productId || 'notifications';
options.twilsockClient = options.twilsockClient || new twilsock_1.TwilsockClient(token, productId, options);
options.transport = options.transport || options.twilsockClient;
this.services = {
twilsock: options.twilsockClient,
transport: options.transport,
config: new configuration_1.Configuration(null, options)
};
this.registrar = new registrar_1.Registrar(productId, this.services.transport, this.services.twilsock, this.services.config);
this.reliableTransportState = {
overall: false,
transport: false,
registration: false,
lastEmitted: null
};
this._onTransportStateChange(this.services.twilsock.isConnected);
this.registrar.on('transportReady', state => {
this._onRegistrationStateChange(state ? 'registered' : '');
});
this.registrar.on('stateChanged', (state) => {
this._onRegistrationStateChange(state);
});
this.registrar.on('needReliableTransport', this._onNeedReliableTransport.bind(this));
this.services.twilsock.on('message', (type, message) => this._routeMessage(type, message));
this.services.twilsock.on('connected', (notificationId) => {
this._onTransportStateChange(true);
this.registrar.setNotificationId('twilsock', notificationId);
});
this.services.twilsock.on('disconnected', () => {
this._onTransportStateChange(false);
});
this.updateToken(token);
}
options = options || {};
options.logLevel = options.logLevel || 'error';
_logger2.default.setLevel(options.logLevel);
var minTokenRefreshInterval = options.minTokenRefreshInterval || 10000;
var productId = options.productId || 'notifications';
options.twilsockClient = options.twilsockClient || new _twilsock2.default(fpaToken, options);
options.transport = options.transport || new _twilioTransport2.default(options.twilsockClient);
options.emsClient = options.emsClient || new _twilioEmsClient.EMSClient(options);
var twilsock = options.twilsockClient;
var transport = options.transport;
var reliableTransportState = {
overall: false,
transport: false,
registration: false,
lastEmitted: null
};
var config = new _configuration2.default(null, options);
(0, _defineProperties2.default)(_this, {
_config: { value: config },
_emsClient: { value: options.emsClient },
_registrar: { value: new _registrar2.default(productId, transport, twilsock, config) },
_twilsock: { value: twilsock },
_reliableTransportState: { value: reliableTransportState },
updateToken: { value: limit(_this._updateToken.bind(_this), 1, minTokenRefreshInterval), enumerable: true },
connectionState: {
get: function get() {
if (_this._twilsock.state === 'disconnected') {
get connectionState() {
if (this.services.twilsock.state === 'disconnected') {
return 'disconnected';
} else if (_this._twilsock.state === 'disconnecting') {
}
else if (this.services.twilsock.state === 'disconnecting') {
return 'disconnecting';
} else if (_this._twilsock.state === 'connected' && _this._reliableTransportState.registration) {
}
else if (this.services.twilsock.state === 'connected' && this.reliableTransportState.registration) {
return 'connected';
} else if (_this._twilsock.state === 'rejected') {
}
else if (this.services.twilsock.state === 'rejected') {
return 'denied';
}
return 'connecting';
}
}
});
_this._emsClient.setToken(fpaToken).then(function (response) {
_this._config.updateToken(response.token);
_this._registrar.updateToken();
}).catch(function (e) {
_logger2.default.warn('Failed to set token', e);
});
_this._onTransportStateChange(_this._twilsock.connected);
_this._registrar.on('transportReady', function (state) {
_this._onRegistrationStateChange(state ? 'registered' : '');
});
_this._registrar.on('stateChanged', function (state) {
_this._onRegistrationStateChange(state);
});
_this._registrar.on('needReliableTransport', _this._onNeedReliableTransport.bind(_this));
_this._twilsock.on('message', function (type, message) {
return _this._routeMessage(type, message);
});
_this._twilsock.on('connected', function (notificationId) {
_this._onTransportStateChange(true);
_this._registrar.setNotificationId('twilsock', notificationId);
});
_this._twilsock.on('disconnected', function () {
_this._onTransportStateChange(false);
});
return _this;
}
/**
* Routes messages to the external subscribers
* @private
*/
(0, _createClass3.default)(Client, [{
key: '_routeMessage',
value: function _routeMessage(type, message) {
_logger2.default.trace('Message arrived: ', type, message);
this.emit('message', type, message);
return 'connecting';
}
}, {
key: '_onNeedReliableTransport',
value: function _onNeedReliableTransport(isNeeded) {
if (isNeeded) {
this._twilsock.connect();
} else {
this._twilsock.disconnect();
}
/**
* Routes messages to the external subscribers
* @private
*/
_routeMessage(type, message) {
logger_1.log.trace('Message arrived: ', type, message);
this.emit('message', type, message);
}
}, {
key: '_onRegistrationStateChange',
value: function _onRegistrationStateChange(state) {
this._reliableTransportState.registration = state === 'registered';
this._updateTransportState();
_onNeedReliableTransport(isNeeded) {
if (isNeeded) {
this.services.twilsock.connect();
}
else {
this.services.twilsock.disconnect();
}
}
}, {
key: '_onTransportStateChange',
value: function _onTransportStateChange(connected) {
this._reliableTransportState.transport = connected;
this._updateTransportState();
_onRegistrationStateChange(state) {
this.reliableTransportState.registration = (state === 'registered');
this._updateTransportState();
}
}, {
key: '_updateTransportState',
value: function _updateTransportState() {
var overallState = this._reliableTransportState.transport && this._reliableTransportState.registration;
if (this._reliableTransportState.overall !== overallState) {
this._reliableTransportState.overall = overallState;
_logger2.default.info('Transport ready ' + overallState);
this.emit('transportReady', overallState);
}
if (this._reliableTransportState.lastEmitted !== this.connectionState) {
this._reliableTransportState.lastEmitted = this.connectionState;
this.emit('connectionStateChanged', this.connectionState);
}
_onTransportStateChange(connected) {
this.reliableTransportState.transport = connected;
this._updateTransportState();
}
_updateTransportState() {
const overallState = this.reliableTransportState.transport
&& this.reliableTransportState.registration;
if (this.reliableTransportState.overall !== overallState) {
this.reliableTransportState.overall = overallState;
logger_1.log.info('Transport ready:', overallState);
this.emit('transportReady', overallState);
}
if (this.reliableTransportState.lastEmitted !== this.connectionState) {
this.reliableTransportState.lastEmitted = this.connectionState;
this.emit('connectionStateChanged', this.connectionState);
}
}
/**

@@ -236,14 +118,7 @@ * Adds the subscription for the given message type

* @param {string} channelType. Supported are 'twilsock', 'gcm' and 'fcm'
* @public
*/
}, {
key: 'subscribe',
value: function subscribe(messageType, channelType) {
channelType = channelType || 'twilsock';
_logger2.default.trace('Add subscriptions for message type: ', messageType, channelType);
return this._registrar.subscribe(messageType, channelType);
subscribe(messageType, channelType = 'twilsock') {
logger_1.log.trace('Add subscriptions for message type: ', messageType, channelType);
return this.registrar.subscribe(messageType, channelType);
}
/**

@@ -253,86 +128,57 @@ * Remove the subscription for the particular message type

* @param {string} channelType. Supported are 'twilsock', 'gcm' and 'fcm'
* @public
*/
}, {
key: 'unsubscribe',
value: function unsubscribe(messageType, channelType) {
channelType = channelType || 'twilsock';
_logger2.default.trace('Remove subscriptions for message type: ', messageType, channelType);
return this._registrar.unsubscribe(messageType, channelType);
unsubscribe(messageType, channelType = 'twilsock') {
logger_1.log.trace('Remove subscriptions for message type: ', messageType, channelType);
return this.registrar.unsubscribe(messageType, channelType);
}
/**
* Handle incoming push notification.
* Client application should call this method when it receives push notifications and pass the received data
* @param {Object} msg - push message object
* @public
* @param {Object} message push message
* @return {PushNotification}
*/
}, {
key: 'handlePushNotification',
value: function handlePushNotification(msg) {
_logger2.default.warn('Push message passed, but no functionality implemented yet: ' + msg);
handlePushNotification(message) {
return {
messageType: message.twi_message_type,
payload: message.payload
};
}
/**
* Set GCM/FCM token to enable application register for a push messages
* Set APN/GCM/FCM token to enable application register for a push messages
* @param {string} gcmToken/fcmToken Token received from GCM/FCM system
* @public
*/
}, {
key: 'setPushRegistrationId',
value: function setPushRegistrationId(registrationId, type) {
this._registrar.setNotificationId(type || 'gcm', registrationId);
setPushRegistrationId(registrationId, channelType) {
logger_1.log.trace('Set push registration id', registrationId, channelType);
this.registrar.setNotificationId(channelType, registrationId);
}
/**
* Updates auth token for registration
* @param {string} token Authentication token for registrations
* @alias updateToken
* @public
*/
}, {
key: '_updateToken',
value: function _updateToken(fpaToken) {
var _this2 = this;
_logger2.default.info('authTokenUpdated');
if (this._fpaToken === fpaToken) {
return _promise2.default.resolve();
}
this._twilsock.updateToken(fpaToken);
return this._emsClient.setToken(fpaToken).then(function (response) {
return response.token;
}).then(function (token) {
_this2._config.updateToken(token);
_this2._registrar.updateToken();
});
async updateToken(token) {
logger_1.log.info('authTokenUpdated');
if (this.services.config.token === token) {
return;
}
this.services.twilsock.updateToken(token);
this.services.config.updateToken(token);
this.registrar.updateToken(token);
}
}]);
return Client;
}(_events2.default);
}
exports.Client = Client;
/**
* Fired when new message arrived.
* @param {Object} message`
* @event NotificationsClient#message
* @event Client#message
*/
/**
* Fired when transport state has changed
* @param {boolean} transport state
* @event NotificationsClient#transportReady
* @event Client#transportReady
*/
/**
* Fired when transport state has been changed
* @param {string} transport state
* @event NotificationsClient#connectionStateChanged
* @event Client#connectionStateChanged
*/
/**

@@ -344,5 +190,1 @@ * These options can be passed to Client constructor

*/
exports.default = Client;
module.exports = exports['default'];

72

lib/configuration.js

@@ -1,56 +0,18 @@

'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _defineProperties = require('babel-runtime/core-js/object/define-properties');
var _defineProperties2 = _interopRequireDefault(_defineProperties);
var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
var _createClass2 = require('babel-runtime/helpers/createClass');
var _createClass3 = _interopRequireDefault(_createClass2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var ERS_URI = 'https://ers.twilio.com';
var ERS_PATH = '/v1/registrations';
var NotificationConfig = function () {
function NotificationConfig(token, options) {
var _this = this;
(0, _classCallCheck3.default)(this, NotificationConfig);
options = (options || {}).Notification || {};
var uri = options.ersUri || ERS_URI;
(0, _defineProperties2.default)(this, {
_registrarUri: { value: uri + ERS_PATH },
_token: { value: token, writable: true },
registrarUri: { get: function get() {
return _this._registrarUri;
} },
token: { get: function get() {
return _this._token;
} }
});
}
(0, _createClass3.default)(NotificationConfig, [{
key: 'updateToken',
value: function updateToken(token) {
this._token = token;
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class Configuration {
constructor(token, options = {}) {
let config = options.notifications || {};
const region = config.region || options.region || 'us1';
const defaultUrl = `https://ers.${region}.twilio.com/v1/registrations`;
this.registrarUrl = config.ersUrl || defaultUrl;
this._token = token;
}
}]);
return NotificationConfig;
}();
exports.default = NotificationConfig;
module.exports = exports['default'];
updateToken(token) {
this._token = token;
}
get token() {
return this._token;
}
}
exports.Configuration = Configuration;

18

lib/index.js

@@ -1,14 +0,4 @@

'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _client = require('./client');
var _client2 = _interopRequireDefault(_client);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.default = _client2.default;
module.exports = exports['default'];
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const client_1 = require("./client");
exports.Notifications = client_1.Client;

64

lib/logger.js

@@ -1,42 +0,26 @@

'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _from = require('babel-runtime/core-js/array/from');
var _from2 = _interopRequireDefault(_from);
var _loglevel = require('loglevel');
var _loglevel2 = _interopRequireDefault(_loglevel);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const logger = require("loglevel");
function prepareLine(prefix, args) {
return [prefix].concat((0, _from2.default)(args));
return [prefix].concat(Array.from(args));
}
exports.default = {
setLevel: function setLevel(level) {
_loglevel2.default.setLevel(level);
},
trace: function trace() {
_loglevel2.default.trace.apply(null, prepareLine('Notify T:', arguments));
},
debug: function debug() {
_loglevel2.default.debug.apply(null, prepareLine('Notify D:', arguments));
},
info: function info() {
_loglevel2.default.info.apply(null, prepareLine('Notify I:', arguments));
},
warn: function warn() {
_loglevel2.default.warn.apply(null, prepareLine('Notify W:', arguments));
},
error: function error() {
_loglevel2.default.error.apply(null, prepareLine('Notify E:', arguments));
}
};
module.exports = exports['default'];
class Logger {
constructor() {
this.prefix = '';
}
static scope(prefix = '') {
// TBD this.prefix += ' ' + prefix;
return new Logger();
}
setLevel(level) {
logger.setLevel(level);
}
trace(...args) { logger.debug.apply(null, prepareLine('Notifications T:' + this.prefix, args)); }
debug(...args) { logger.debug.apply(null, prepareLine('Notifications D:' + this.prefix, args)); }
info(...args) { logger.info.apply(null, prepareLine('Notifications I:' + this.prefix, args)); }
warn(...args) { logger.warn.apply(null, prepareLine('Notifications W:' + this.prefix, args)); }
error(...args) { logger.error.apply(null, prepareLine('Notifications E:' + this.prefix, args)); }
}
exports.Logger = Logger;
let logInstance = Logger.scope();
exports.log = logInstance;

434

lib/registrar.connector.js

@@ -1,359 +0,91 @@

'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _freeze = require('babel-runtime/core-js/object/freeze');
var _freeze2 = _interopRequireDefault(_freeze);
var _promise = require('babel-runtime/core-js/promise');
var _promise2 = _interopRequireDefault(_promise);
var _set2 = require('babel-runtime/core-js/set');
var _set3 = _interopRequireDefault(_set2);
var _defineProperties = require('babel-runtime/core-js/object/define-properties');
var _defineProperties2 = _interopRequireDefault(_defineProperties);
var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
var _createClass2 = require('babel-runtime/helpers/createClass');
var _createClass3 = _interopRequireDefault(_createClass2);
var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
var _inherits2 = require('babel-runtime/helpers/inherits');
var _inherits3 = _interopRequireDefault(_inherits2);
var _events = require('events');
var _events2 = _interopRequireDefault(_events);
var _logger = require('./logger');
var _logger2 = _interopRequireDefault(_logger);
var _javascriptStateMachine = require('javascript-state-machine');
var _javascriptStateMachine2 = _interopRequireDefault(_javascriptStateMachine);
var _backoff = require('backoff');
var _backoff2 = _interopRequireDefault(_backoff);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function toArray(_set) {
var arr = [];
_set.forEach(function (v) {
return arr.push(v);
});
return arr;
}
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const operation_retrier_1 = require("operation-retrier");
const logger_1 = require("./logger");
const connector_1 = require("./connector");
exports.Connector = connector_1.Connector;
let retrierConfig = {
min: 2000,
max: 120000,
randomness: 0.2
};
/**
* Creates new instance of the ERS registrar
*
* @class RegistrarConnector
* @classdesc Manages the registrations on ERS service.
* It deduplicates registrations and manages them automatically
*
* @param Object configuration
* @param string notificationId
* @param string channelType
* @param Array messageTypes
* Manages the registrations on ERS service.
* Deduplicates registrations and manages them automatically
*/
var RegistrarConnector = function (_EventEmitter) {
(0, _inherits3.default)(RegistrarConnector, _EventEmitter);
function RegistrarConnector(context, transport, config, channelType) {
(0, _classCallCheck3.default)(this, RegistrarConnector);
var _this = (0, _possibleConstructorReturn3.default)(this, (RegistrarConnector.__proto__ || (0, _getPrototypeOf2.default)(RegistrarConnector)).call(this));
var fsm = _javascriptStateMachine2.default.create({
initial: { state: 'unregistered', event: 'init', defer: true },
events: [{ name: 'userUpdate', from: ['unregistered'], to: 'registering' }, { name: 'userUpdate', from: ['registered'], to: 'unregistering' }, { name: 'registered', from: ['registering', 'retrying'], to: 'registered' }, { name: 'unregistered', from: ['unregistering'], to: 'unregistered' }, { name: 'retry', from: ['retrying'], to: 'retrying' }, { name: 'failure', from: ['registering'], to: 'retrying' }, { name: 'failure', from: ['retrying'], to: 'retrying' }, { name: 'failure', from: ['unregistering'], to: 'unregistered' }],
callbacks: {
onregistering: function onregistering(event, from, to, arg) {
return _this._register(arg);
},
onunregistering: function onunregistering() {
return _this._unregister();
},
onregistered: function onregistered() {
return _this._onRegistered();
},
onunregistered: function onunregistered() {
return _this._onUnregistered();
},
onretrying: function onretrying(event, from, to, arg) {
return _this._initRetry(arg);
},
onfailure: function onfailure(event, from, to, arg) {
if (from === 'retrying') {
_this._initRetry(arg);
}
}
}
});
var backoff = _backoff2.default.exponential({
randomisationFactor: 0.2,
initialDelay: 2 * 1000,
maxDelay: 2 * 60 * 1000
});
backoff.on('ready', function () {
_this._retry();
});
(0, _defineProperties2.default)(_this, {
_transport: { value: transport },
_context: { value: context },
_url: { value: config.registrarUri, writable: false },
_config: { value: config },
_fsm: { value: fsm },
_backoff: { value: backoff },
_channelType: { value: channelType },
_registrationId: { value: false, writable: true },
_notificationId: { value: false, writable: true },
_messageTypes: { value: new _set3.default(), writable: true },
_pendingUpdate: { value: null, writable: true }
});
fsm.init();
return _this;
}
(0, _createClass3.default)(RegistrarConnector, [{
key: 'setNotificationId',
value: function setNotificationId(notificationId) {
if (this._notificationId === notificationId) {
return;
}
this._notificationId = notificationId;
this._updateRegistration();
}
}, {
key: 'updateToken',
value: function updateToken() {
return this._updateRegistration();
}
}, {
key: 'has',
value: function has(messageType) {
return this._messageTypes.has(messageType);
}
}, {
key: 'subscribe',
value: function subscribe(messageType) {
if (this._messageTypes.has(messageType)) {
_logger2.default.debug('Message type already registered ', messageType);
return false;
}
this._messageTypes.add(messageType);
this._updateRegistration();
return true;
}
}, {
key: 'unsubscribe',
value: function unsubscribe(messageType) {
if (!this._messageTypes.has(messageType)) {
return false;
}
this._messageTypes.delete(messageType);
if (this._messageTypes.size > 0) {
this._updateRegistration();
} else {
this._removeRegistration();
}
return true;
}
}, {
key: '_updateRegistration',
value: function _updateRegistration() {
if (this._notificationId) {
this._update(this._notificationId, toArray(this._messageTypes));
}
}
}, {
key: '_removeRegistration',
value: function _removeRegistration() {
if (this._notificationId) {
this._update(this._notificationId, toArray(this._messageTypes));
}
}
class RegistrarConnector extends connector_1.Connector {
/**
* Update service registration
* @param {Array} messageTypes Array of message type names
* @private
* Creates new instance of the ERS registrar
*
* @param Object configuration
* @param string notificationId
* @param string channelType
* @param Array messageTypes
*/
}, {
key: '_update',
value: function _update(notificationId, messageTypes) {
var regData = { notificationId: notificationId, messageTypes: messageTypes };
if (this._fsm.is('unregistered')) {
if (regData.notificationId && regData.messageTypes.length > 0) {
this._fsm.userUpdate(regData);
constructor(channelType, context, transport, config) {
super(config);
this.channelType = channelType;
this.context = context;
this.transport = transport;
}
async updateRegistration(registration, reasons) {
if (reasons.has('notificationId')) {
await this.removeRegistration();
}
} else if (this._fsm.is('registered')) {
this._fsm.userUpdate(regData);
this._setPendingUpdate(regData);
} else {
this._setPendingUpdate(regData);
}
if (!registration.notificationId || !registration.notificationId.length) {
return registration;
}
await this.register(registration);
return registration;
}
}, {
key: '_setPendingUpdate',
value: function _setPendingUpdate(regData) {
this._pendingUpdate = regData;
async removeRegistration() {
if (!this.registrationId) {
return;
}
const url = `${this.config.registrarUrl}/${this.registrationId}?productId=${this.context.productId}`;
const headers = {
'Content-Type': 'application/json',
'X-Twilio-Token': this.config.token
};
try {
logger_1.log.trace('Removing registration for ', this.channelType);
await new operation_retrier_1.Retrier(Object.assign(retrierConfig, { maxAttemptsCount: 3 }))
.run(() => this.transport.delete(url, headers));
logger_1.log.debug('Registration removed for', this.channelType);
}
catch (err) {
logger_1.log.error('Failed to remove of registration ', this.channelType, err);
throw err;
}
}
}, {
key: '_checkPendingUpdate',
value: function _checkPendingUpdate() {
if (!this._pendingUpdate) {
return;
}
var pendingUpdate = this._pendingUpdate;
this._pendingUpdate = null;
this._updateRegistration(pendingUpdate.notificationId, pendingUpdate.messageTypes);
async register(registration) {
logger_1.log.trace('Registering', this.channelType, registration);
let registrarRequest = {
endpoint_platform: this.context.platform,
channel_type: this.channelType,
version: this.context.protocolVersion.toString(),
message_types: Array.from(registration.messageTypes),
data: {
registration_id: registration.notificationId
},
ttl: 'PT24H'
};
const url = `${this.config.registrarUrl}?productId=${this.context.productId}`;
const headers = {
'Content-Type': 'application/json',
'X-Twilio-Token': registration.token
};
logger_1.log.trace('Creating registration for channel ', this.channelType);
try {
let response = await new operation_retrier_1.Retrier(retrierConfig)
.run(() => this.transport.post(url, headers, registrarRequest));
this.registrationId = response.body.id;
logger_1.log.debug('Registration created: ', response);
}
catch (err) {
logger_1.log.error('Registration failed: ', err);
throw err;
}
}
}, {
key: '_initRetry',
value: function _initRetry(regData) {
if (!this._pendingUpdate) {
this._setPendingUpdate(regData);
}
this._backoff.backoff();
}
}, {
key: '_retry',
value: function _retry() {
if (!this._pendingUpdate) {
return;
}
var pendingUpdate = this._pendingUpdate;
this._pendingUpdate = null;
this._register(pendingUpdate);
}
}, {
key: '_onRegistered',
value: function _onRegistered() {
this._backoff.reset();
this.emit('stateChanged', 'registered');
this._checkPendingUpdate();
}
}, {
key: '_onUnregistered',
value: function _onUnregistered() {
this._backoff.reset();
this.emit('stateChanged', 'unregistered');
this._checkPendingUpdate();
}
}, {
key: '_register',
value: function _register(regData) {
var _this2 = this;
/* eslint-disable camelcase */
var registrarRequest = {
endpoint_platform: this._context.platform,
channel_type: this._channelType,
version: '2',
message_types: regData.messageTypes,
data: {},
ttl: 'PT24H'
};
if (this._channelType === 'twilsock') {
registrarRequest.data.url = regData.notificationId;
} else {
registrarRequest.data.registration_id = regData.notificationId;
}
var uri = this._url + '?productId=' + this._context.productId;
var headers = {
'Content-Type': 'application/json',
'X-Twilio-Token': this._config.token
};
/* eslint-enable camelcase */
_logger2.default.trace('Creating registration for channel ', this._channelType);
return this._transport.post(uri, headers, registrarRequest).then(function (response) {
_this2._registrationId = response.body.id;
_this2._registrationData = regData;
_logger2.default.debug('Registration created: ', response);
_this2._fsm.registered();
}).catch(function (error) {
_logger2.default.error('Registration failed: ', error);
_this2._fsm.failure(regData);
return error;
});
}
}, {
key: '_unregister',
value: function _unregister() {
var _this3 = this;
if (!this._registrationId) {
return _promise2.default.resolve();
}
var uri = this._url + '/' + this._registrationId + '?productId=' + this._context.productId;
var headers = {
'Content-Type': 'application/json',
'X-Twilio-Token': this._config.token
};
_logger2.default.trace('Removing registration for ', this._channelType);
return this._transport.delete(uri, headers).then(function () {
_logger2.default.debug('Registration removed for ', _this3._channelType);
_this3._registrationId = false;
_this3._fsm.unregistered();
}).catch(function (reason) {
// failure to remove registration since being treated as "unregistered" state
// because it is indicates that something wrong with server/connection
_logger2.default.error('Failed to remove of registration ', _this3.channelType, reason);
_this3._fsm.failure();
return reason;
});
}
}]);
return RegistrarConnector;
}(_events2.default);
exports.default = RegistrarConnector;
(0, _freeze2.default)(RegistrarConnector);
module.exports = exports['default'];
}
exports.RegistrarConnector = RegistrarConnector;

214

lib/registrar.js

@@ -1,111 +0,34 @@

'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _freeze = require('babel-runtime/core-js/object/freeze');
var _freeze2 = _interopRequireDefault(_freeze);
var _map = require('babel-runtime/core-js/map');
var _map2 = _interopRequireDefault(_map);
var _defineProperties = require('babel-runtime/core-js/object/define-properties');
var _defineProperties2 = _interopRequireDefault(_defineProperties);
var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
var _createClass2 = require('babel-runtime/helpers/createClass');
var _createClass3 = _interopRequireDefault(_createClass2);
var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
var _inherits2 = require('babel-runtime/helpers/inherits');
var _inherits3 = _interopRequireDefault(_inherits2);
var _events = require('events');
var _events2 = _interopRequireDefault(_events);
var _registrar = require('./registrar.connector');
var _registrar2 = _interopRequireDefault(_registrar);
var _twilsock = require('./twilsock.connector');
var _twilsock2 = _interopRequireDefault(_twilsock);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const registrar_connector_1 = require("./registrar.connector");
const twilsock_connector_1 = require("./twilsock.connector");
/**
* Creates the new instance of ERS registrar client
*
* @class Registrar
* @classdesc Provides an interface to the ERS registrar
* Provides an interface to the ERS registrar
*/
var Registrar = function (_EventEmitter) {
(0, _inherits3.default)(Registrar, _EventEmitter);
function Registrar(productId, transport, twilsock, config) {
(0, _classCallCheck3.default)(this, Registrar);
var _this = (0, _possibleConstructorReturn3.default)(this, (Registrar.__proto__ || (0, _getPrototypeOf2.default)(Registrar)).call(this));
(0, _defineProperties2.default)(_this, {
_conf: { value: config },
_connectors: { value: new _map2.default() }
});
var platform = _this._detectPlatform();
_this._connectors.set('twilsock', new _twilsock2.default({ productId: productId, platform: platform }, twilsock, config));
_this._connectors.set('gcm', new _registrar2.default({ productId: productId, platform: platform }, transport, config, 'gcm'));
_this._connectors.set('fcm', new _registrar2.default({ productId: productId, platform: platform }, transport, config, 'fcm'));
_this._connectors.set('apn', new _registrar2.default({ productId: productId, platform: platform }, transport, config, 'apn'));
_this._connectors.get('twilsock').on('transportReady', function (state) {
return _this.emit('transportReady', state);
});
return _this;
}
/**
* Sets notification ID.
* If new URI is different from previous, it triggers updating of registration for given channel
*
* @param {string} channelType channel type (apn|gcm|fcm|twilsock)
* @param {string} notificationId The notification ID
*/
(0, _createClass3.default)(Registrar, [{
key: 'setNotificationId',
value: function setNotificationId(channelType, notificationId) {
this._connector(channelType).setNotificationId(notificationId);
class Registrar extends events_1.EventEmitter {
/**
* Creates the new instance of registrar client
*/
constructor(productId, transport, twilsock, config) {
super();
this.config = config;
this.connectors = new Map();
const platform = this.detectPlatform();
this.connectors.set('gcm', new registrar_connector_1.RegistrarConnector('gcm', { protocolVersion: 3, productId, platform }, transport, config));
this.connectors.set('fcm', new registrar_connector_1.RegistrarConnector('fcm', { protocolVersion: 3, productId, platform }, transport, config));
this.connectors.set('apn', new registrar_connector_1.RegistrarConnector('apn', { protocolVersion: 4, productId, platform }, transport, config));
this.connectors.set('twilsock', new twilsock_connector_1.TwilsockConnector({ productId, platform }, twilsock, config));
this.connectors.get('twilsock').on('transportReady', state => this.emit('transportReady', state));
}
/**
* Checks if subscription for given message and channel already exists
* Sets notification ID.
* If new URI is different from previous, it triggers updating of registration for given channel
*
* @param {string} channelType channel type (apn|gcm|fcm|twilsock)
* @param {string} notificationId The notification ID
*/
}, {
key: 'hasSubscription',
value: function hasSubscription(messageType, channelType) {
this._connector(channelType).has(messageType);
setNotificationId(channelType, notificationId) {
this.connector(channelType).setNotificationId(notificationId);
}
/**

@@ -118,9 +41,5 @@ * Subscribe for given type of message

*/
}, {
key: 'subscribe',
value: function subscribe(messageType, channelType) {
this._connector(channelType).subscribe(messageType);
subscribe(messageType, channelType) {
return this.connector(channelType).subscribe(messageType);
}
/**

@@ -130,65 +49,40 @@ * Remove subscription

* @param {String} channelType Channel type (twilsock or gcm/fcm)
* @public
*/
}, {
key: 'unsubscribe',
value: function unsubscribe(messageType, channelType) {
this._connector(channelType).unsubscribe(messageType);
unsubscribe(messageType, channelType) {
return this.connector(channelType).unsubscribe(messageType);
}
}, {
key: 'updateToken',
value: function updateToken() {
this._connectors.forEach(function (connector) {
return connector.updateToken();
});
updateToken(token) {
this.connectors.forEach(connector => connector.updateToken(token));
}
/**
* @param {String} type Channel type
* @throws {Error} Error with description
* @private
*/
}, {
key: '_connector',
value: function _connector(type) {
var connector = this._connectors.get(type);
if (!connector) {
throw new Error('Unknown channel type: ' + type);
}
return connector;
connector(type) {
let connector = this.connectors.get(type);
if (!connector) {
throw new Error(`Unknown channel type: ${type}`);
}
return connector;
}
/**
* Returns platform string limited to max 128 chars
* @private
*/
}, {
key: '_detectPlatform',
value: function _detectPlatform() {
var _platform = '';
if (typeof navigator !== 'undefined') {
_platform = 'unknown';
if (typeof navigator.product !== 'undefined') {
_platform = navigator.product;
detectPlatform() {
let platform = '';
if (typeof navigator !== 'undefined') {
platform = 'unknown';
if (typeof navigator.product !== 'undefined') {
platform = navigator.product;
}
if (typeof navigator.userAgent !== 'undefined') {
platform = navigator.userAgent;
}
}
if (typeof navigator.userAgent !== 'undefined') {
_platform = navigator.userAgent;
else {
platform = 'web';
}
} else {
_platform = 'web';
}
return _platform.substring(0, 128);
return platform.substring(0, 128);
}
}]);
return Registrar;
}(_events2.default);
exports.default = Registrar;
(0, _freeze2.default)(Registrar);
module.exports = exports['default'];
}
exports.Registrar = Registrar;

248

lib/twilsock.connector.js

@@ -1,210 +0,52 @@

'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _freeze = require('babel-runtime/core-js/object/freeze');
var _freeze2 = _interopRequireDefault(_freeze);
var _set2 = require('babel-runtime/core-js/set');
var _set3 = _interopRequireDefault(_set2);
var _defineProperties = require('babel-runtime/core-js/object/define-properties');
var _defineProperties2 = _interopRequireDefault(_defineProperties);
var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
var _createClass2 = require('babel-runtime/helpers/createClass');
var _createClass3 = _interopRequireDefault(_createClass2);
var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
var _inherits2 = require('babel-runtime/helpers/inherits');
var _inherits3 = _interopRequireDefault(_inherits2);
var _uuid = require('uuid');
var _uuid2 = _interopRequireDefault(_uuid);
var _logger = require('./logger');
var _logger2 = _interopRequireDefault(_logger);
var _events = require('events');
var _events2 = _interopRequireDefault(_events);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var DEFAULT_TTL = 60 * 60 * 48;
function toArray(_set) {
var arr = [];
_set.forEach(function (v) {
return arr.push(v);
});
return arr;
}
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const uuid = require("uuid");
const connector_1 = require("./connector");
const DEFAULT_TTL = 60 * 60 * 48;
/**
* @class
* @classdesc Registrar connector implementation for twilsock
*
* @constructor
* Registrar connector implementation for twilsock
*/
var TwilsockConnector = function (_EventEmitter) {
(0, _inherits3.default)(TwilsockConnector, _EventEmitter);
function TwilsockConnector(context, twilsock, config) {
(0, _classCallCheck3.default)(this, TwilsockConnector);
var _this = (0, _possibleConstructorReturn3.default)(this, (TwilsockConnector.__proto__ || (0, _getPrototypeOf2.default)(TwilsockConnector)).call(this));
context.id = _uuid2.default.v4();
(0, _defineProperties2.default)(_this, {
_twilsock: { value: twilsock },
_messageTypes: { value: new _set3.default() },
config: { value: config },
context: { value: context }
});
twilsock.on('stateChanged', function (state) {
if (state !== 'connected') {
_this.emit('transportReady', false);
}
});
twilsock.on('registered', function (id) {
if (context && id === context.id && twilsock.state === 'connected') {
_this.emit('transportReady', true);
}
});
return _this;
}
/**
* @public
*/
(0, _createClass3.default)(TwilsockConnector, [{
key: 'setNotificationId',
value: function setNotificationId() {
return false;
class TwilsockConnector extends connector_1.Connector {
constructor(context, twilsock, config) {
super(config);
this.twilsock = twilsock;
this.context = context;
context.id = uuid.v4();
this.twilsock.on('stateChanged', state => {
if (state !== 'connected') {
this.emit('transportReady', false);
}
});
this.twilsock.on('registered', id => {
if (context && id === context.id && twilsock.state === 'connected') {
this.emit('transportReady', true);
}
});
}
/**
* @public
*/
}, {
key: 'updateToken',
value: function updateToken() {
this._twilsock.removeNotificationsContext(this.context.id);
this.context.id = _uuid2.default.v4();
this._updateContext();
setNotificationId(...args) { }
updateToken(token) {
// no need to do anything here, twilsock backend handles it on it's own
// so just ignoring here
}
/**
* @public
*/
}, {
key: 'has',
value: function has(messageType) {
return this._messageTypes.has(messageType);
async updateContextRequest(messageTypes) {
let context = {
product_id: this.context.productId,
notification_protocol_version: 4,
endpoint_platform: this.context.platform,
message_types: messageTypes
};
this.emit('transportReady', false);
await this.twilsock.setNotificationsContext(this.context.id, context);
}
/**
* @public
*/
}, {
key: 'subscribe',
value: function subscribe(messageType) {
if (this._messageTypes.has(messageType)) {
_logger2.default.trace('Message type already registered ', messageType);
return false;
}
this._messageTypes.add(messageType);
this._updateContext();
return true;
async updateRegistration(registration, reasons) {
if (!reasons.has('messageType')) {
return;
}
await this.updateContextRequest(Array.from(registration.messageTypes));
return registration;
}
/**
* @public
*/
}, {
key: 'unsubscribe',
value: function unsubscribe(messageType) {
if (!this._messageTypes.has(messageType)) {
return false;
}
this._messageTypes.delete(messageType);
if (this._messageTypes.size > 0) {
this._updateContext();
} else {
this._twilsock.removeNotificationsContext(this.context.id);
}
return true;
removeRegistration() {
return this.twilsock.removeNotificationsContext(this.context.id);
}
/**
* @private
*/
}, {
key: '_updateContext',
value: function _updateContext() {
if (!this.config.token) {
// no token, can't do anything, ignore
return;
}
var messageTypes = toArray(this._messageTypes);
/* eslint-disable camelcase */
var context = {
product_id: this.context.productId,
notification_protocol_version: 4,
endpoint_platform: this.context.platform,
ttl: DEFAULT_TTL,
token: this.config.token,
message_types: messageTypes
};
/* eslint-enable camelcase */
this.emit('transportReady', false);
this._twilsock.setNotificationsContext(this.context.id, context);
}
}]);
return TwilsockConnector;
}(_events2.default);
exports.default = TwilsockConnector;
(0, _freeze2.default)(TwilsockConnector);
module.exports = exports['default'];
}
exports.TwilsockConnector = TwilsockConnector;

103

package.json
{
"name": "twilio-notifications",
"version": "0.4.4",
"version": "0.5.0",
"description": "Client library for Twilio Notifications service",
"main": "lib/index.js",
"types": "./lib/index.d.ts",
"repository": {

@@ -12,57 +13,73 @@ "type": "git",

"test": "gulp unit-test",
"prepublish": "node_modules/babel-cli/bin/babel.js src --out-dir lib"
"prepublish": "gulp build"
},
"author": "Twilio",
"license": "ISC",
"license": "MIT",
"dependencies": {
"backoff": "^2.5.0",
"bottleneck": "^1.15.1",
"javascript-state-machine": "^2.4.0",
"loglevel": "^1.4.1",
"twilio-ems-client": "^0.2.0",
"twilio-transport": "^0.1.1",
"twilsock": "^0.3.0",
"uuid": "^3.0.1"
"twilsock": "^0.5.1",
"loglevel": "^1.6.1",
"operation-retrier": "^2.0.0",
"uuid": "^3.2.1"
},
"devDependencies": {
"async": "^2.1.4",
"async-test-tools": "^1.0.6",
"babel-cli": "^6.23.0",
"babel-eslint": "^7.1.1",
"babel-plugin-add-module-exports": "^0.2.1",
"babel-plugin-transform-object-assign": "^6.22.0",
"@types/chai": "^4.1.2",
"@types/event-to-promise": "^0.7.0",
"@types/loglevel": "^1.5.3",
"@types/mocha": "^2.2.48",
"@types/node": "^9.4.6",
"@types/sinon": "^4.1.3",
"@types/sinon-chai": "^2.7.29",
"@types/uuid": "^3.4.3",
"async-test-tools": "^1.0.7",
"babel-core": "^6.26.0",
"babel-plugin-transform-runtime": "^6.23.0",
"babel-preset-es2015": "^6.22.0",
"babelify": "^7.3.0",
"browserify": "^14.1.0",
"chai": "^3.5.0",
"chai-as-promised": "^6.0.0",
"chai-spies": "^0.7.1",
"cheerio": "^0.22.0",
"event-to-promise": "^0.7.0",
"gulp": "^3.9.1",
"babel-preset-env": "^1.6.1",
"babel-runtime": "^6.26.0",
"babelify": "^8.0.0",
"browserify": "^16.1.0",
"chai": "^4.1.2",
"chai-as-promised": "^7.1.1",
"chai-spies": "^1.0.0",
"cheerio": "^1.0.0-rc.2",
"del": "^3.0.0",
"gulp": "^4.0.0",
"gulp-babel": "^7.0.1",
"gulp-derequire": "^2.1.0",
"gulp-eslint": "^3.0.1",
"gulp-exit": "0.0.2",
"gulp-insert": "^0.5.0",
"gulp-istanbul": "^1.1.1",
"gulp-mocha": "^3.0.1",
"gulp-istanbul": "^1.1.3",
"gulp-mocha": "^5.0.0",
"gulp-rename": "^1.2.2",
"gulp-replace": "^0.5.4",
"gulp-tap": "^0.1.3",
"gulp-uglify": "^2.0.1",
"gulp-replace": "^0.6.1",
"gulp-tap": "^1.0.1",
"gulp-tslint": "^8.1.3",
"gulp-typescript": "^4.0.1",
"gulp-uglify-es": "^1.0.1",
"gulp-util": "^3.0.8",
"ink-docstrap": "^1.3.0",
"ink-docstrap": "^1.3.2",
"isparta": "^4.0.0",
"jsdoc": "^3.4.3",
"jsonwebtoken": "^7.3.0",
"proxyquire": "^1.7.11",
"run-sequence": "^1.2.2",
"sinon": "^1.17.7",
"sinon-as-promised": "^4.0.2",
"sinon-chai": "^2.8.0",
"twilio": "^3.3.0-edge",
"vinyl-buffer": "^1.0.0",
"vinyl-source-stream": "^1.1.0"
"jsdoc": "^3.5.5",
"jsonwebtoken": "^8.1.1",
"loglevel-message-prefix": "^3.0.0",
"proxyquire": "^1.8.0",
"run-sequence": "^2.2.1",
"sinon": "^4.3.0",
"sinon-chai": "^2.14.0",
"ts-node": "^5.0.0",
"tsdoc": "0.0.4",
"tslint": "^5.9.1",
"twilio": "^3.11.3",
"typescript": "^2.8.1",
"uglify-save-license": "^0.4.1",
"vinyl-buffer": "^1.0.1",
"vinyl-source-stream": "^2.0.0"
},
"browserify": {
"transform": [
"babelify"
]
},
"engines": {
"node": ">=8"
}
}
.eslintrc
.idea/.name
.idea/compiler.xml
.idea/copyright/profiles_settings.xml
.idea/encodings.xml
.idea/misc.xml
.idea/modules.xml
.idea/notifications-js-lib.iml
.idea/vcs.xml
.idea/workspace.xml
.npmignore
build/twilio-notifications-bundle.js
dist/coverage/cobertura-coverage.xml
dist/coverage/lcov-report/base.css
dist/coverage/lcov-report/index.html
dist/coverage/lcov-report/prettify.css
dist/coverage/lcov-report/prettify.js
dist/coverage/lcov-report/sort-arrow-sprite.png
dist/coverage/lcov-report/sorter.js
dist/coverage/lcov-report/src/client.js.html
dist/coverage/lcov-report/src/configuration.js.html
dist/coverage/lcov-report/src/index.html
dist/coverage/lcov-report/src/index.js.html
dist/coverage/lcov-report/src/logger.js.html
dist/coverage/lcov-report/src/registrar.connector.js.html
dist/coverage/lcov-report/src/registrar.js.html
dist/coverage/lcov-report/src/twilsock.connector.js.html
dist/coverage/lcov.info
dist/twilio-notifications.js

Sorry, the diff of this file is too big to display

dist/twilio-notifications.min.js

Sorry, the diff of this file is too big to display

examples/gcm/index.html

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc