ironflock 0.0.6

package/README.md

@@ -0,0 +1,46 @@
+# ironflock
+
+## About
+
+With this library you can publishing data to IronFlock fleet storage.
+When this library is used on a certain device the library automatically uses the private messaging realm (Unified Name Space)
+of the device's fleet and the data is collected in the respective fleet database.
+
+So if you use the library in your app, the data collection will always be private to the app user's fleet.
+
+## Usage
+
+**CommonJS**
+
+```
+const IronFlock = require("ironflock")
+const ironflock = new IronFlock()
+
+ironflock.publish("re.example.rpc", [{ example_data: "test" }]) // any type of data is publishable
+```
+
+**ES6**
+
+For ES6 modules `"type": "module"` is required in your package.json
+
+```
+import IronFlock from "ironflock"
+const ironflock = new IronFlock()
+
+ironflock.publish("re.example.rpc", [{ example_data: "test" }]) // any type of data is publishable
+```
+
+## Options
+
+The `IronFlock` constructor can be configured with the following options:
+
+```
+{
+    quiet?: boolean;
+    serialNumber?: string;
+}
+```
+
+**quiet**: Toggles autobahn.js debug information
+
+**serialNumber**: Used to set the serial_number of the device if the `DEVICE_SERIAL_NUMBER` environment variable does not exist. It can also be used if the user wishes to authenticate as another device.

package/dist/crossbar/index.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="when" />
+/// <reference types="node" />
+import autobahn from "autobahn";
+import { EventEmitter } from "stream";
+export type Details = {
+    caller_authid: string;
+    caller_authrole: string;
+};
+export type AuthPayload = {
+    success: boolean;
+    role: string;
+    realm: string;
+    authid: string;
+    extra: {
+        username: string;
+    };
+};
+export declare class CrossbarConnection extends EventEmitter {
+    session?: autobahn.Session;
+    connection?: autobahn.Connection;
+    serial_number: string;
+    socketURI: string;
+    realm: string;
+    private reconnectTimeout?;
+    constructor(serial_number: string);
+    private init;
+    getSession(): autobahn.Session | undefined;
+    isConnected(): boolean | undefined;
+    /**
+     *
+     * @param {string} procedure
+     * @param {any | undefined} args
+     * @param {any | undefined} kwargs
+     * @param {autobahn.ICallOptions} options
+     */
+    call<T>(procedure: string, args?: any[], kwargs?: object, options?: any): When.Promise<T> | undefined;
+    publish(topic: string, args?: any[], kwargs?: object, options?: any): When.Promise<autobahn.IPublication> | undefined;
+}

package/dist/crossbar/index.js

@@ -0,0 +1,150 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossbarConnection = void 0;
+var autobahn_1 = __importDefault(require("autobahn"));
+var stream_1 = require("stream");
+// import { MsgpackSerializer } from "./serializer";
+var RESWARM_URL = process.env.RESWARM_URL;
+var DATAPODS_WS_URI = "ws://devices.datapods.io:8088/ws";
+var STUDIO_WS_URI = "ws://devices.record-evolution.com:8088/ws";
+var LOCALHOST_WS_URI = "ws://reswarm-crossbar:8088";
+var socketURIMap = {
+    "https://studio.datapods.io": DATAPODS_WS_URI,
+    "https://studio.record-evolution.com": STUDIO_WS_URI,
+    "http://localhost:8085": LOCALHOST_WS_URI
+};
+var CrossbarConnection = /** @class */ (function (_super) {
+    __extends(CrossbarConnection, _super);
+    function CrossbarConnection(serial_number) {
+        var _this = _super.call(this) || this;
+        _this.serial_number = serial_number;
+        _this.realm = "userapps";
+        _this.socketURI = RESWARM_URL ? socketURIMap[RESWARM_URL] : DATAPODS_WS_URI;
+        _this.init();
+        return _this;
+    }
+    CrossbarConnection.prototype.init = function () {
+        var _this = this;
+        this.connection = new autobahn_1.default.Connection({
+            realm: this.realm,
+            url: this.socketURI,
+            authmethods: ["wampcra"],
+            authid: this.serial_number,
+            max_retries: -1,
+            max_retry_delay: 5,
+            initial_retry_delay: 1,
+            // @ts-ignore
+            // serializers: [new MsgpackSerializer()],
+            // @ts-ignore
+            autoping_interval: 2,
+            autoping_timeout: 4,
+            onchallenge: function (session, method, extra) {
+                return autobahn_1.default.auth_cra.sign(_this.serial_number, extra.challenge);
+            },
+        });
+        this.connection.onopen = function (session, details) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.session = session;
+                this.session.caller_disclose_me = true;
+                this.emit('connected', this.serial_number);
+                return [2 /*return*/];
+            });
+        }); };
+        this.connection.onclose = function (reason, details) {
+            _this.emit('disconnected');
+            console.log("connection closed: ", reason, details);
+            console.log("retrying in 1 second..");
+            if (_this.reconnectTimeout)
+                clearTimeout(_this.reconnectTimeout);
+            _this.reconnectTimeout = setTimeout(function () {
+                _this.emit('reconnecting');
+                _this.init();
+            }, 1000);
+            return true;
+        };
+        this.connection.open();
+    };
+    CrossbarConnection.prototype.getSession = function () {
+        return this.session;
+    };
+    CrossbarConnection.prototype.isConnected = function () {
+        return this.session && this.session.isOpen;
+    };
+    /**
+     *
+     * @param {string} procedure
+     * @param {any | undefined} args
+     * @param {any | undefined} kwargs
+     * @param {autobahn.ICallOptions} options
+     */
+    CrossbarConnection.prototype.call = function (procedure, args, kwargs, options) {
+        var _a;
+        if (!this.isConnected()) {
+            throw new Error("cannot call without a connected session");
+        }
+        return (_a = this.session) === null || _a === void 0 ? void 0 : _a.call(procedure, args, kwargs, options);
+    };
+    CrossbarConnection.prototype.publish = function (topic, args, kwargs, options) {
+        var _a;
+        if (!this.isConnected()) {
+            throw new Error("cannot call without a connected session");
+        }
+        return (_a = this.session) === null || _a === void 0 ? void 0 : _a.publish(topic, args, kwargs, options);
+    };
+    return CrossbarConnection;
+}(stream_1.EventEmitter));
+exports.CrossbarConnection = CrossbarConnection;

package/dist/crossbar/serializer.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+export declare class MsgpackSerializer {
+    SERIALIZER_ID: string;
+    BINARY: boolean;
+    constructor();
+    serialize(obj: any): Buffer;
+    unserialize(payload: Buffer): any;
+}

package/dist/crossbar/serializer.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgpackSerializer = void 0;
+var msgpack = __importStar(require("msgpack-lite"));
+var MsgpackSerializer = /** @class */ (function () {
+    function MsgpackSerializer() {
+        this.SERIALIZER_ID = 'msgpack';
+        this.BINARY = true;
+    }
+    MsgpackSerializer.prototype.serialize = function (obj) {
+        try {
+            var payload = msgpack.encode(obj);
+            return payload;
+        }
+        catch (e) {
+            console.warn('MessagePack encoding error', e);
+            throw e;
+        }
+    };
+    MsgpackSerializer.prototype.unserialize = function (payload) {
+        try {
+            var obj = msgpack.decode(payload);
+            return obj;
+        }
+        catch (e) {
+            console.warn('MessagePack decoding error', e);
+            throw e;
+        }
+    };
+    return MsgpackSerializer;
+}());
+exports.MsgpackSerializer = MsgpackSerializer;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { IronFlock } from "./ironflock";
+export = IronFlock;

package/dist/index.js

@@ -0,0 +1,3 @@
+"use strict";
+var ironflock_1 = require("./ironflock");
+module.exports = ironflock_1.IronFlock;

package/dist/ironflock.d.ts

@@ -0,0 +1,18 @@
+type TOptions = {
+    quiet?: boolean;
+    serialNumber?: string;
+};
+export declare class IronFlock {
+    private crossbarSession;
+    private onConnectTasks;
+    private options?;
+    constructor(options?: TOptions);
+    private onConnected;
+    private executeAllQueuedTasks;
+    private queue;
+    private _publish;
+    publish(topic: string, data: any): Promise<any>;
+    onConnect(cb: Function): void;
+    onDisconnect(cb: Function): void;
+}
+export {};

package/dist/ironflock.js

@@ -0,0 +1,153 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IronFlock = void 0;
+var crossbar_1 = require("./crossbar");
+var _a = process.env, DEVICE_SERIAL_NUMBER = _a.DEVICE_SERIAL_NUMBER, DEVICE_NAME = _a.DEVICE_NAME;
+var IronFlock = /** @class */ (function () {
+    function IronFlock(options) {
+        this.onConnectTasks = [];
+        this.options = { quiet: true };
+        if (!DEVICE_SERIAL_NUMBER && !(options === null || options === void 0 ? void 0 : options.serialNumber)) {
+            throw new Error("the DEVICE_SERIAL_NUMBER environment variable is not defined");
+        }
+        var device_serial_number = DEVICE_SERIAL_NUMBER ? DEVICE_SERIAL_NUMBER : options === null || options === void 0 ? void 0 : options.serialNumber;
+        if (options) {
+            this.options = __assign(__assign({}, this.options), options);
+        }
+        this.onConnected = this.onConnected.bind(this);
+        this.crossbarSession = new crossbar_1.CrossbarConnection(device_serial_number);
+        this.crossbarSession.on("connected", this.onConnected);
+    }
+    IronFlock.prototype.onConnected = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                if (!((_a = this.options) === null || _a === void 0 ? void 0 : _a.quiet)) {
+                    console.log("Successfully established a socket connection as ".concat(this.crossbarSession.serial_number, " with ").concat(this.crossbarSession.socketURI, "!"));
+                }
+                return [2 /*return*/, this.executeAllQueuedTasks()];
+            });
+        });
+    };
+    IronFlock.prototype.executeAllQueuedTasks = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(this.onConnectTasks.map(function (t) { return t(); }))];
+                    case 1:
+                        _a.sent();
+                        this.onConnectTasks = [];
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    IronFlock.prototype.queue = function (task) {
+        return __awaiter(this, void 0, void 0, function () {
+            var taskResult;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.crossbarSession.isConnected()) return [3 /*break*/, 2];
+                        return [4 /*yield*/, task()];
+                    case 1:
+                        taskResult = _a.sent();
+                        return [2 /*return*/, taskResult !== null && taskResult !== void 0 ? taskResult : true];
+                    case 2: return [2 /*return*/, new Promise(function (resolve, reject) {
+                            _this.onConnectTasks.push(function () { return __awaiter(_this, void 0, void 0, function () {
+                                var taskResult, error_1;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            return [4 /*yield*/, task()];
+                                        case 1:
+                                            taskResult = _a.sent();
+                                            resolve(taskResult !== null && taskResult !== void 0 ? taskResult : true);
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            error_1 = _a.sent();
+                                            reject(error_1);
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
+                                    }
+                                });
+                            }); });
+                        })];
+                }
+            });
+        });
+    };
+    IronFlock.prototype._publish = function (topic, data) {
+        // checks for null and undefined
+        if (data == null) {
+            throw new Error("null or undefined cannot be published as payload");
+        }
+        var args = Array.isArray(data) ? data : [data];
+        var kwargs = {
+            DEVICE_SERIAL_NUMBER: this.crossbarSession.serial_number,
+            DEVICE_NAME: DEVICE_NAME,
+        };
+        return this.crossbarSession.publish(topic, args, kwargs);
+    };
+    IronFlock.prototype.publish = function (topic, data) {
+        var _this = this;
+        return this.queue(function () { return _this._publish.apply(_this, [topic, data]); });
+    };
+    IronFlock.prototype.onConnect = function (cb) {
+        this.crossbarSession.on("connected", function () { return cb(); });
+    };
+    IronFlock.prototype.onDisconnect = function (cb) {
+        this.crossbarSession.on("disconnected", function () { return cb(); });
+    };
+    return IronFlock;
+}());
+exports.IronFlock = IronFlock;

package/dist/test/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/index.js

@@ -0,0 +1,69 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var ironflock_1 = require("../ironflock");
+(function () {
+    return __awaiter(this, void 0, void 0, function () {
+        var options, ironflock, i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    options = { serialNumber: '603fca74-c45b-4c5e-bd22-24988fd077e6' };
+                    ironflock = new ironflock_1.IronFlock(options);
+                    for (i = 0; i < 20; i++) {
+                        ironflock.publish("re.datapods.meetup", {
+                            temperature: i,
+                        });
+                    }
+                    console.log("Published 20 temperature entries");
+                    console.log("Waiting 2 seconds...");
+                    return [4 /*yield*/, new Promise(function (res) { return setTimeout(res, 2000); })];
+                case 1:
+                    _a.sent();
+                    console.log("Done waiting 2 seconds!");
+                    for (i = i; i < 40; i++) {
+                        ironflock.publish("re.datapods.meetup", {
+                            temperature: i,
+                        });
+                    }
+                    console.log("Published another 20 temperature entries");
+                    return [2 /*return*/];
+            }
+        });
+    });
+})();

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export declare function isPlainObject(o: any): boolean;

package/dist/utils/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = void 0;
+function isObject(o) {
+    return Object.prototype.toString.call(o) === "[object Object]";
+}
+function isPlainObject(o) {
+    var ctor, prot;
+    if (isObject(o) === false)
+        return false;
+    // If has modified constructor
+    ctor = o.constructor;
+    if (ctor === undefined)
+        return true;
+    // If has modified prototype
+    prot = ctor.prototype;
+    if (isObject(prot) === false)
+        return false;
+    // If constructor does not have an Object-specific method
+    if (prot.hasOwnProperty("isPrototypeOf") === false) {
+        return false;
+    }
+    // Most likely a plain Object
+    return true;
+}
+exports.isPlainObject = isPlainObject;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "ironflock",
+  "version": "0.0.6",
+  "description": "Collect data in the IronFlock Storage architecture",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Record Evolution GmbH",
+  "license": "MIT",
+  "dependencies": {
+    "autobahn": "https://gitpkg.now.sh/jszczypk/autobahn-js/packages/autobahn?patch-1",
+    "cbor": "^9.0.1",
+    "msgpack-lite": "^0.1.26",
+    "msgpack5": "^6.0.2",
+    "node-gyp": "^10.0.1",
+    "ws": "^7.5.5"
+  },
+  "scripts": {
+    "prepublish": "rm -rf dist && tsc",
+    "release": "npm version patch --tag-version-prefix='' && git push && git push --tag"
+  },
+  "devDependencies": {
+    "@types/autobahn": "^20.9.4",
+    "@types/msgpack-lite": "^0.1.11",
+    "@types/node": "^16.11.10"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RecordEvolution/reswarm-js.git"
+  },
+  "keywords": [
+    "ironflock",
+    "messaging"
+  ],
+  "bugs": {
+    "url": "https://github.com/RecordEvolution/reswarm-js/issues"
+  },
+  "homepage": "https://github.com/RecordEvolution/reswarm-js#readme"
+}

package/src/crossbar/index.ts

@@ -0,0 +1,122 @@
+import autobahn from "autobahn";
+import { EventEmitter } from "stream";
+// import { MsgpackSerializer } from "./serializer";
+const { RESWARM_URL } = process.env
+
+export type Details = { caller_authid: string; caller_authrole: string };
+
+export type AuthPayload = {
+  success: boolean;
+  role: string;
+  realm: string;
+  authid: string;
+  extra: {
+    username: string;
+  };
+};
+
+const DATAPODS_WS_URI = "ws://devices.datapods.io:8088/ws";
+const STUDIO_WS_URI = "ws://devices.record-evolution.com:8088/ws";
+const LOCALHOST_WS_URI = "ws://reswarm-crossbar:8088";
+
+const socketURIMap: Record<string, string> = {
+  "https://studio.datapods.io": DATAPODS_WS_URI,
+  "https://studio.record-evolution.com": STUDIO_WS_URI,
+  "http://localhost:8085": LOCALHOST_WS_URI
+};
+
+export class CrossbarConnection extends EventEmitter {
+  session?: autobahn.Session;
+  connection?: autobahn.Connection;
+  serial_number: string;
+  socketURI: string;
+  realm: string;
+
+  private reconnectTimeout?: any;
+
+  constructor(serial_number: string) {
+    super()
+    this.serial_number = serial_number;
+    this.realm = "userapps";
+    this.socketURI = RESWARM_URL ? socketURIMap[RESWARM_URL] : DATAPODS_WS_URI;
+
+    this.init();
+  }
+
+  private init() {
+    this.connection = new autobahn.Connection({
+      realm: this.realm,
+      url: this.socketURI,
+      authmethods: ["wampcra"],
+      authid: this.serial_number,
+      max_retries: -1,
+      max_retry_delay: 5,
+      initial_retry_delay: 1,
+      // @ts-ignore
+      // serializers: [new MsgpackSerializer()],
+      // @ts-ignore
+      autoping_interval: 2,
+      autoping_timeout: 4,
+      onchallenge: (session, method, extra) => {
+        return autobahn.auth_cra.sign(this.serial_number, extra.challenge);
+      },
+    });
+
+    this.connection.onopen = async (session, details) => {
+      this.session = session;
+      this.session.caller_disclose_me = true;
+
+      this.emit('connected', this.serial_number)
+    };
+
+    this.connection.onclose = (reason, details) => {
+      this.emit('disconnected')
+
+      console.log("connection closed: ", reason, details);
+
+      console.log("retrying in 1 second..");
+
+      if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = setTimeout(() => {
+        this.emit('reconnecting')
+
+        this.init();
+      }, 1000);
+
+      return true;
+    };
+
+    this.connection.open();
+  }
+
+  getSession() {
+    return this.session;
+  }
+
+  isConnected() {
+    return this.session && this.session.isOpen
+  }
+
+  /**
+   *
+   * @param {string} procedure
+   * @param {any | undefined} args
+   * @param {any | undefined} kwargs
+   * @param {autobahn.ICallOptions} options
+   */
+  call<T>(procedure: string, args?: any[], kwargs?: object, options?: any) {
+    if (!this.isConnected()) {
+      throw new Error("cannot call without a connected session");
+    }
+
+    return this.session?.call<T>(procedure, args, kwargs, options);
+  }
+
+  publish(topic: string, args?: any[], kwargs?: object, options?: any) {
+    if (!this.isConnected()) {
+      throw new Error("cannot call without a connected session");
+    }
+
+    return this.session?.publish(topic, args, kwargs, options);
+  }
+}

package/src/crossbar/serializer.ts

@@ -0,0 +1,31 @@
+import * as msgpack from 'msgpack-lite';
+
+export class MsgpackSerializer {
+  public SERIALIZER_ID: string;
+  public BINARY: boolean;
+
+  constructor() {
+    this.SERIALIZER_ID = 'msgpack';
+    this.BINARY = true;
+  }
+
+  public serialize(obj: any): Buffer {
+    try {
+      const payload: Buffer = msgpack.encode(obj);
+      return payload;
+    } catch (e) {
+      console.warn('MessagePack encoding error', e);
+      throw e;
+    }
+  }
+
+  public unserialize(payload: Buffer): any {
+    try {
+      const obj: any = msgpack.decode(payload);
+      return obj;
+    } catch (e) {
+      console.warn('MessagePack decoding error', e);
+      throw e;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import { IronFlock } from "./ironflock";
+
+export = IronFlock;

package/src/ironflock.ts

@@ -0,0 +1,91 @@
+import { CrossbarConnection } from "./crossbar";
+
+const { DEVICE_SERIAL_NUMBER, DEVICE_NAME } = process.env;
+
+type TOptions = {
+  quiet?: boolean;
+  serialNumber?: string;
+}
+
+export class IronFlock {
+  private crossbarSession: CrossbarConnection;
+  private onConnectTasks: Function[] = [];
+  private options?: TOptions = { quiet: true }
+
+  constructor(options?: TOptions) {
+    if (!DEVICE_SERIAL_NUMBER && !options?.serialNumber) {
+      throw new Error(
+        "the DEVICE_SERIAL_NUMBER environment variable is not defined"
+      );
+    }
+
+    const device_serial_number = DEVICE_SERIAL_NUMBER ? DEVICE_SERIAL_NUMBER : options?.serialNumber as string
+
+    if (options) {
+      this.options = { ...this.options, ...options }
+    }
+
+    this.onConnected = this.onConnected.bind(this)
+    this.crossbarSession = new CrossbarConnection(device_serial_number);
+    this.crossbarSession.on("connected", this.onConnected)
+  }
+
+  private async onConnected() {
+    if (!this.options?.quiet) {
+      console.log(`Successfully established a socket connection as ${this.crossbarSession.serial_number} with ${this.crossbarSession.socketURI}!`)
+    }
+
+    return this.executeAllQueuedTasks()
+  }
+
+  private async executeAllQueuedTasks() {
+    await Promise.all(this.onConnectTasks.map(t => t()));
+
+    this.onConnectTasks = [];
+  }
+
+  private async queue(task: Function) {
+    if (this.crossbarSession.isConnected()) {
+      const taskResult = await task()
+      return taskResult ?? true;
+    }
+
+    return new Promise((resolve, reject) => {
+      this.onConnectTasks.push(async () => {
+        try {
+          const taskResult = await task();
+          resolve(taskResult ?? true);
+        } catch (error) {
+          reject(error)
+        }
+      });
+    });
+  }
+
+  private _publish(topic: string, data: any) {
+    // checks for null and undefined
+    if (data == null) {
+      throw new Error("null or undefined cannot be published as payload")
+    }
+
+    const args = Array.isArray(data) ? data : [data];
+    const kwargs = {
+      DEVICE_SERIAL_NUMBER: this.crossbarSession.serial_number,
+      DEVICE_NAME,
+    };
+
+    return this.crossbarSession.publish(topic, args, kwargs);
+  }
+
+  publish(topic: string, data: any) {
+    return this.queue(() => this._publish.apply(this, [topic, data]));
+  }
+
+  onConnect(cb: Function) {
+    this.crossbarSession.on("connected", () => cb());
+  }
+
+  onDisconnect(cb: Function) {
+    this.crossbarSession.on("disconnected", () => cb());
+  }
+}

package/src/test/index.ts

@@ -0,0 +1,28 @@
+import { IronFlock } from "../ironflock";
+
+(async function () {
+  const options = { serialNumber: '603fca74-c45b-4c5e-bd22-24988fd077e6' }
+  const ironflock = new IronFlock(options);
+
+  for (var i = 0; i < 20; i++) {
+    ironflock.publish("re.datapods.meetup", {
+      temperature: i,
+    });
+  }
+
+  console.log("Published 20 temperature entries")
+
+  console.log("Waiting 2 seconds...")
+
+  await new Promise((res) => setTimeout(res, 2000));
+
+  console.log("Done waiting 2 seconds!")
+
+  for (i = i; i < 40; i++) {
+    ironflock.publish("re.datapods.meetup", {
+      temperature: i,
+    });
+  }
+
+  console.log("Published another 20 temperature entries")
+})();

package/src/utils/index.ts

@@ -0,0 +1,25 @@
+function isObject(o: any) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+
+export function isPlainObject(o: any) {
+  var ctor, prot;
+
+  if (isObject(o) === false) return false;
+
+  // If has modified constructor
+  ctor = o.constructor;
+  if (ctor === undefined) return true;
+
+  // If has modified prototype
+  prot = ctor.prototype;
+  if (isObject(prot) === false) return false;
+
+  // If constructor does not have an Object-specific method
+  if (prot.hasOwnProperty("isPrototypeOf") === false) {
+    return false;
+  }
+
+  // Most likely a plain Object
+  return true;
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "CommonJS",
+    "lib": [
+      "es2017",
+      "es7",
+      "es6"
+    ],
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "include": ["src"],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}