sockethub 5.0.0-alpha.0 → 5.0.0-alpha.3

package/src/sockethub-client.test.ts

@@ -1,235 +0,0 @@
-import proxyquire from 'proxyquire';
-import { expect } from 'chai';
-import * as sinon from 'sinon';
-import { EventEmitter2 } from 'eventemitter2';
-
-proxyquire.noPreserveCache();
-proxyquire.noCallThru();
-
-describe("SockethubClient bad initialization", () => {
-  it("no socket.io instance", () => {
-    const SockethubClient = proxyquire('./sockethub-client', {
-      'activity-streams': (config: any) => {}
-    });
-    expect(() => {
-      const junk = new SockethubClient();
-    }).to.throw("SockethubClient requires a socket.io instance");
-  });
-});
-
-describe("SockethubClient", () => {
-  let ASManager, socket, sc, sandbox;
-
-  beforeEach(() => {
-    sandbox = sandbox = sinon.createSandbox();
-    socket = new EventEmitter2();
-    // @ts-ignore
-    socket.__instance = 'socketio'; // used to uniquely identify the object we're passing in
-    sandbox.spy(socket, 'on');
-    sandbox.spy(socket, 'emit');
-    ASManager = new EventEmitter2();
-    sandbox.spy(ASManager, 'on');
-    sandbox.spy(ASManager, 'emit');
-    ASManager.Stream = sandbox.stub();
-    ASManager.Object = {
-      create: sandbox.stub()
-    };
-    const SockethubClient = proxyquire('./sockethub-client', {
-      'activity-streams': (config: any) => {
-        return ASManager;
-      }
-    });
-    sc = new SockethubClient(socket);
-    sandbox.spy(sc.socket, 'on');
-    sandbox.spy(sc.socket, '_on');
-    sandbox.spy(sc.socket, 'emit');
-    sandbox.spy(sc.socket, '_emit');
-  });
-
-  afterEach(() => {
-    sinon.restore();
-  });
-
-  it("contains the ActivityStreams property", () => {
-    expect(sc.ActivityStreams).to.be.eql(ASManager);
-  });
-
-  it("contains the socket property", () => {
-    expect(sc.socket instanceof EventEmitter2).to.be.true;
-    // the object we passed in should not be the publically available one
-    expect(sc.socket.__instance).to.not.equal('socketio');
-    expect(sc.debug).to.be.true;
-    expect(sc.online).to.be.false;
-  });
-
-  it("registers listeners for ActivityStream events", () => {
-    expect(ASManager.on.callCount).to.equal(1);
-    expect(ASManager.on.calledWithMatch('activity-object-create')).to.be.true;
-  });
-
-  it("registers a listeners for socket events", () => {
-    expect(socket.on.callCount).to.equal(5);
-    expect(socket.on.calledWithMatch('activity-object')).to.be.true;
-    expect(socket.on.calledWithMatch('connect')).to.be.true;
-    expect(socket.on.calledWithMatch('connect_error')).to.be.true;
-    expect(socket.on.calledWithMatch('disconnect')).to.be.true;
-    expect(socket.on.calledWithMatch('message')).to.be.true;
-  });
-
-  describe("event handling", () => {
-    it("activity-object", (done) => {
-      socket.emit('activity-object', {foo:"bar"});
-      setTimeout(() => {
-        sandbox.assert.calledWith(ASManager.Object.create, {foo:"bar"});
-        done();
-      }, 0);
-    });
-
-    it("activity-object-create", (done) => {
-      ASManager.emit('activity-object-create', {foo:"bar"});
-      setTimeout(() => {
-        expect(socket.emit.callCount).to.equal(1);
-        expect(socket.emit.calledWithMatch('activity-object', {foo:"bar"})).to.be.true;
-        done();
-      }, 0);
-    });
-
-    it("connect", (done) => {
-      expect(sc.online).to.be.false;
-      sc.socket.on("connect", () => {
-        expect(sc.online).to.be.true;
-        expect(sc.socket._emit.callCount).to.equal(1);
-        expect(sc.socket._emit.calledWithMatch('connect'));
-        done();
-      });
-      socket.emit("connect");
-    });
-
-    it("disconnect", (done) => {
-      sc.online = true;
-      sc.socket.on("disconnect", () => {
-        expect(sc.online).to.be.false;
-        expect(sc.socket._emit.callCount).to.equal(1);
-        expect(sc.socket._emit.calledWithMatch('disconnect'));
-        done();
-      });
-      socket.emit("disconnect");
-    });
-
-    it("connect_error", (done) => {
-      sc.socket.on("connect_error", () => {
-        expect(sc.socket._emit.callCount).to.equal(1);
-        expect(sc.socket._emit.calledWithMatch('connect_error'));
-        done();
-      });
-      socket.emit("connect_error");
-    });
-
-    it("message", (done) => {
-      sc.socket.on("message", () => {
-        expect(sc.socket._emit.callCount).to.equal(1);
-        expect(sc.socket._emit.calledWithMatch('message'));
-        done();
-      });
-      socket.emit("message");
-    });
-  });
-
-  describe("event emitting", () => {
-    it("message (no actor)", () => {
-      sc.online = true;
-      const callback = (res) => {};
-      expect(() => {
-        sc.socket.emit("message", {foo:"bar"}, callback);
-      }).to.throw("actor property not present");
-    });
-
-    it("message", (done) => {
-      sc.online = true;
-      const callback = (res) => {};
-      socket.once("message", (data, cb) => {
-        expect(data).to.be.eql({actor: "bar", type: "bar"});
-        expect(cb).to.be.eql(callback);
-        done();
-      });
-      sc.socket.emit("message", {actor:"bar", type: "bar"}, callback);
-    });
-
-    it("message (join)", (done) => {
-      sc.online = true;
-      const callback = (res) => {};
-      socket.once("message", (data, cb) => {
-        expect(data).to.be.eql({actor: "bar", type: "join"});
-        expect(cb).to.be.eql(callback);
-        done();
-      });
-      sc.socket.emit("message", {actor:"bar", type: "join"}, callback);
-    });
-
-    it("message (leave)", (done) => {
-      sc.online = true;
-      const callback = (res) => {};
-      socket.once("message", (data, cb) => {
-        expect(data).to.be.eql({actor: "bar", type: "leave"});
-        expect(cb).to.be.eql(callback);
-        done();
-      });
-      sc.socket.emit("message", {actor:"bar", type: "leave"}, callback);
-    });
-
-    it("message (connect)", (done) => {
-      sc.online = true;
-      const callback = (res) => {};
-      socket.once("message", (data, cb) => {
-        expect(data).to.be.eql({actor: "bar", type: "connect"});
-        expect(cb).to.be.eql(callback);
-        done();
-      });
-      sc.socket.emit("message", {actor:"bar", type: "connect"}, callback);
-    });
-
-    it("message (disconnect)", (done) => {
-      sc.online = true;
-      const callback = (res) => {};
-      socket.once("message", (data, cb) => {
-        expect(data).to.be.eql({actor: "bar", type: "disconnect"});
-        expect(cb).to.be.eql(callback);
-        done();
-      });
-      sc.socket.emit("message", {actor:"bar", type: "disconnect"}, callback);
-    });
-
-    it("message (offline)", (done) => {
-      sc.online = false;
-      const callback = (res) => {};
-      socket.once("message", (data, cb) => {
-        expect(data).to.be.eql({actor: "bar"});
-        expect(cb).to.be.eql(callback);
-        done();
-      });
-      sc.socket.emit("message", {actor:"bar"}, callback);
-    });
-
-    it("activity-object", (done) => {
-      sc.online = true;
-      const callback = (res) => {};
-      socket.once("activity-object", (data, cb) => {
-        expect(data).to.be.eql({actor: "bar"});
-        expect(cb).to.be.eql(callback);
-        done();
-      });
-      sc.socket.emit("activity-object", {actor:"bar"}, callback);
-    });
-
-    it("credentials", (done) => {
-      sc.online = true;
-      const callback = (res) => {};
-      socket.once("credentials", (data, cb) => {
-        expect(data).to.be.eql({actor: "bar"});
-        expect(cb).to.be.eql(callback);
-        done();
-      });
-      sc.socket.emit("credentials", {actor:"bar"}, callback);
-    });
-  });
-});

package/src/sockethub-client.ts

@@ -1,164 +0,0 @@
-import { EventEmitter2 } from 'eventemitter2';
-import ASFactory from 'activity-streams';
-
-export interface ActivityObjectManager {
-  create(obj: any): any;
-  delete(id: string): boolean;
-  list(): Array<string>,
-  get(id: string, expand: boolean): any;
-}
-
-export interface ASManager {
-  Stream(meta: any): any,
-  Object: ActivityObjectManager,
-  on(event, func): void;
-  once(event, func): void;
-  off(event, funcName): void;
-}
-
-class SockethubClient {
-  private _socket;
-  private events = {
-    'credentials': new Map(),
-    'activity-object': new Map(),
-    'connect': new Map(),
-    'join': new Map()
-  };
-  public socket;
-  public ActivityStreams: ASManager;
-  public online = false;
-  public debug = true;
-
-  constructor(socket) {
-    if (! socket) { throw new Error('SockethubClient requires a socket.io instance'); }
-    this._socket = socket;
-    // @ts-ignore
-    this.ActivityStreams = ASFactory({specialObjs: ['credentials']});
-
-    this.socket = this.createPublicEmitter();
-    this.registerSocketIOHandlers();
-
-    this.ActivityStreams.on('activity-object-create', (obj) => {
-      socket.emit('activity-object', obj, (err) => {
-        if (err) { console.error('failed to create activity-object ', err); }
-        else { this.eventActivityObject(obj); }
-      });
-    });
-
-    socket.on('activity-object', (obj) => {
-      this.ActivityStreams.Object.create(obj);
-    });
-  }
-
-  private createPublicEmitter(): EventEmitter2 {
-    let socket = new EventEmitter2({
-      wildcard: true,
-      verboseMemoryLeak: false
-    });
-    // @ts-ignore
-    socket._emit = socket.emit;
-    socket.emit = (event, content, callback): any => {
-      if (event === 'credentials') {
-        this.eventCredentials(content);
-      } else if (event === 'activity-object') {
-        this.eventActivityObject(content);
-      } else if (event === 'message') {
-        this.eventMessage(content);
-      }
-      this._socket.emit(event, content, callback);
-    };
-    return socket;
-  }
-
-  private eventActivityObject(content: any) {
-    if (content.id) {
-      this.events['activity-object'].set(content.id, content);
-    }
-  }
-
-  private eventCredentials(content: any) {
-    if ((content.object) && (content.object.type === 'credentials')) {
-      this.events['credentials'].set(content.actor.id || content.actor, content);
-    }
-  }
-
-  private eventMessage(content: any) {
-    if (! this.online) { return; }
-    // either store or delete the specified content onto the storedJoins map,
-    // for reply once we're back online.
-    const key = SockethubClient.getKey(content);
-    if (content.type === 'join' || content.type === 'connect') {
-      this.events[content.type].set(key, content);
-    } else if (content.type === 'leave') {
-      this.events['join'].delete(key);
-    } else if (content.type === 'disconnect') {
-      this.events['connect'].delete(key);
-    }
-  }
-
-  private static getKey(content: any) {
-    let actor = content.actor?.id || content.actor;
-    if (! actor) {
-      throw new Error("actor property not present for message type: " + content?.type);
-    }
-    let target = content.target ? content.target.id || content.target : '';
-    return actor + '-' + target;
-  }
-
-  private log(msg: string, obj?: any) {
-    if (this.debug) {
-      // eslint-disable-next-line security-node/detect-crlf
-      console.log(msg, obj);
-    }
-  }
-
-  private registerSocketIOHandlers() {
-    // middleware for events which don't deal in AS objects
-    const callHandler = (event: string) => {
-      return (obj, cb) => {
-        if (event === 'connect') {
-          this.online = true;
-          this.replay('activity-object', this.events['activity-object']);
-          this.replay('credentials', this.events['credentials']);
-          this.replay('message', this.events['connect']);
-          this.replay('message', this.events['join']);
-        } else if (event === 'disconnect') {
-          this.online = false;
-        }
-        this.socket._emit(event, obj, cb);
-      };
-    };
-
-    // register for events that give us information on connection status
-    this._socket.on('connect', callHandler('connect'));
-    this._socket.on('connect_error', callHandler('connect_error'));
-    this._socket.on('disconnect', callHandler('disconnect'));
-
-    // use as a middleware to receive incoming Sockethub messages and unpack them
-    // using the ActivityStreams library before passing them along to the app.
-    this._socket.on('message', (obj, cb) => {
-      this.socket._emit('message', this.ActivityStreams.Stream(obj), cb);
-    });
-  }
-
-  private replay(name: string, asMap: any) {
-    asMap.forEach((obj) => {
-      this.log(`replaying ${name}`, obj);
-      this._socket.emit(name, obj);
-    });
-  };
-}
-
-if (typeof module === 'object' && module.exports) {
-  module.exports = SockethubClient;
-}
-
-if (typeof exports === 'object') {
-  exports = SockethubClient;  // lgtm [js/useless-assignment-to-local]
-}
-
-// @ts-ignore
-if (typeof window === 'object') {
-  // @ts-ignore
-  window.SockethubClient = SockethubClient;
-}

package/src/sockethub.d.ts

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

package/src/sockethub.ts

@@ -1,184 +0,0 @@
-import debug from 'debug';
-import { Socket } from "socket.io";
-
-import crypto from './crypto';
-import init from './bootstrap/init';
-import middleware from './middleware';
-import createActivityObject from "./middleware/create-activity-object";
-import expandActivityStream from "./middleware/expand-activity-stream";
-import storeCredentials from "./middleware/store-credentials";
-import validate from "./middleware/validate";
-import janitor from './janitor';
-import serve from './serve';
-import ProcessManager from "./process-manager";
-import PlatformInstance, { platformInstances } from "./platform-instance";
-import { getSessionStore } from "./store";
-
-const log = debug('sockethub:core');
-
-
-export interface JobDataDecrypted {
-  title?: string;
-  msg: ActivityStream;
-  sessionId: string;
-}
-
-export interface JobDataEncrypted {
-  title?: string;
-  msg: string;
-  sessionId: string;
-}
-
-export interface JobDecrypted {
-  data: JobDataDecrypted,
-  remove?: Function;
-}
-
-export interface JobEncrypted {
-  data: JobDataEncrypted,
-  remove?: Function;
-}
-
-export interface ActivityStream {
-  type: string;
-  context: string;
-  actor: {
-    id: string;
-    type?: string;
-    name?: string;
-  },
-  object?: {
-    type: string;
-    content?: any;
-  },
-  target?: {
-    type: string;
-    id: string;
-    name?: string;
-  },
-  error?: string;
-  sessionSecret?: string;
-}
-
-function attachError(err, msg) {
-  if (typeof msg !== 'object') {
-    msg = { context: 'error' };
-  }
-  msg.error = err.toString();
-  delete msg.sessionSecret;
-  return msg;
-}
-
-class Sockethub {
-  private readonly parentId: string;
-  private readonly parentSecret1: string;
-  private readonly parentSecret2: string;
-  counter: number;
-  platforms: Map<string, object>;
-  status: boolean;
-  queue: any;
-  processManager: ProcessManager;
-
-  constructor() {
-    this.counter = 0;
-    this.platforms = init.platforms;
-    this.status = false;
-    this.parentId = crypto.randToken(16);
-    this.parentSecret1 = crypto.randToken(16);
-    this.parentSecret2 = crypto.randToken(16);
-    this.processManager = new ProcessManager(
-      this.parentId, this.parentSecret1, this.parentSecret2);
-    log('sockethub session id: ' + this.parentId);
-  }
-
-  /**
-   * initialization of sockethub starts here
-   */
-  boot() {
-    if (this.status) {
-      return log('Sockethub.boot() called more than once');
-    } else {
-      this.status = true;
-    }
-
-    log('active platforms: ', [...init.platforms.keys()]);
-    janitor.clean(); // start cleanup cycle
-    serve.start();   // start external services
-    log('registering handlers');
-    serve.io.on('connection', this.handleIncomingConnection.bind(this));
-  }
-
-  async removeAllPlatformInstances() {
-    for (let platform of platformInstances) {
-      await platform[1].destroy();
-    }
-  }
-
-  private createJob(socketId: string, platformInstance: PlatformInstance, msg): JobDataEncrypted {
-    const title = `${msg.context}-${(msg.id) ? msg.id : this.counter++}`;
-    const job: JobDataEncrypted = {
-      title: title,
-      sessionId: socketId,
-      msg: crypto.encrypt(msg, this.parentSecret1 + this.parentSecret2)
-    };
-    return job;
-  };
-
-  private handleIncomingConnection(socket: Socket) {
-    const sessionLog = debug('sockethub:core:' + socket.id), // session-specific debug messages
-          sessionSecret = crypto.randToken(16),
-          // store instance is session-specific
-          store = getSessionStore(this.parentId, this.parentSecret1, socket.id, sessionSecret);
-
-    sessionLog(`socket.io connection`);
-
-    socket.on('disconnect', () => {
-      sessionLog('disconnect received from client');
-    });
-
-    socket.on('credentials',
-      middleware('credentials')
-        .use(expandActivityStream)
-        .use(validate('credentials', socket.id))
-        .use(storeCredentials(store, sessionLog))
-        .use((err, data, next) => {
-          // error handler
-          next(attachError(err, data));
-        }).use((data, next) => { next(); })
-        .done());
-
-    // when new activity objects are created on the client side, an event is
-    // fired and we receive a copy on the server side.
-    socket.on('activity-object',
-      middleware('activity-object')
-        .use(validate('activity-object', socket.id))
-        .use(createActivityObject)
-        .use((err, data, next) => {
-          next(attachError(err, data));
-        }).use((data, next) => { next(); })
-        .done());
-
-    socket.on('message',
-      middleware('message')
-        .use(expandActivityStream)
-        .use(validate('message', socket.id))
-        .use((msg, next) => {
-          // The platform thread must find the credentials on their own using the given
-          // sessionSecret, which indicates that this specific session (socket
-          // connection) has provided credentials.
-          msg.sessionSecret = sessionSecret;
-          next(msg);
-        }).use((err, data, next) => {
-          next(attachError(err, data));
-        }).use((msg, next) => {
-          const platformInstance = this.processManager.get(msg.context, msg.actor.id, socket.id);
-          sessionLog(`queued to channel ${platformInstance.id}`);
-          const job = this.createJob(socket.id, platformInstance, msg);
-          // job validated and queued, store socket.io callback for when job is completed
-          platformInstance.completedJobHandlers.set(job.title, next);
-          platformInstance.queue.add(job);
-        }).done());
-  }
-}
-
-export default Sockethub;

package/src/store.test.ts

@@ -1,26 +0,0 @@
-import proxyquire from 'proxyquire';
-import * as sinon from 'sinon';
-
-proxyquire.noPreserveCache();
-proxyquire.noCallThru();
-
-const MockSecureStore = sinon.fake();
-
-const StoreMod = proxyquire('./store', {
-  'secure-store-redis': MockSecureStore
-});
-
-const getSessionStore = StoreMod.getSessionStore;
-
-describe('getSessionStore', () => {
-  it('returns a valid Store object', () => {
-    const store = getSessionStore('a parent id', 'a parent secret',
-      'a session id', 'a session secret');
-    sinon.assert.calledOnce(MockSecureStore);
-    sinon.assert.calledWith(MockSecureStore, {
-      namespace: 'sockethub:a parent id:session:a session id:store',
-      secret: 'a parent secreta session secret',
-      redis: { host: '127.0.0.1', port: 6379 }
-    });
-  });
-});

package/src/store.ts

@@ -1,17 +0,0 @@
-import SecureStore from 'secure-store-redis';
-
-import config from "./config";
-
-export interface ISecureStoreInstance {
-  save(id: string, obj: any, cb: Function);
-  get(id: string, cb: Function);
-}
-
-export function getSessionStore(parentId: string, parentSecret: string,
-                                sessionId: string, sessionSecret: string): ISecureStoreInstance {
-  return new SecureStore({
-    namespace: 'sockethub:' + parentId + ':session:' + sessionId + ':store',
-    secret: parentSecret + sessionSecret,
-    redis: config.get('redis')
-  });
-}

package/test/init-suite.js

@@ -1,41 +0,0 @@
-if (typeof define !== 'function') {
-  let define = require('amdefine')(module);
-}
-define(['require'], function (require) {
-  return [
-    {
-      desc: 'dist/bootstrap/init',
-      abortOnFail: true,
-      setup: function (env, test) {
-        env.init = require('../dist/bootstrap/init').default;
-        test.assertType(env.init, 'object');
-      },
-      tests: [
-        {
-          desc: 'platforms',
-          run: function (env, test) {
-            test.assertTypeAnd(env.init.platforms, 'object');
-            test.assert(env.init.platforms.has('irc'), true);
-          }
-        }
-      ]
-    },
-    {
-      desc: 'nconf should have defaults set',
-      setup: function (env, test) {
-        env.nconf = require('nconf');
-        test.assertType(env.nconf.get, 'function');
-      },
-      tests: [
-        {
-          desc: 'whitelist and blacklist',
-          run: function (env, test) {
-            console.log('whitelist: ', typeof require('nconf').get('platforms:whitelist'));
-            test.assertTypeAnd(require('nconf').get('platforms:whitelist'), 'array');
-            test.assertType(require('nconf').get('platforms:blacklist'), 'array');
-          }
-        }
-      ]
-    }
-  ];
-});

package/test/sockethub-suite.js

@@ -1,25 +0,0 @@
-if (typeof define !== 'function') {
-  let define = require('amdefine')(module);
-}
-define(['require', '../dist/sockethub'], function (require, Sockethub) {
-  return [
-    {
-      desc: 'src/sockethub',
-      abortOnFail: true,
-      beforeEach: function () {
-        this.env.sockethub = new Sockethub.default();
-        this.done();
-      },
-      tests: [
-        {
-          desc: 'boot',
-          run: function () {
-            this.env.sockethub.boot();
-            this.assertTypeAnd(this.env.sockethub.platforms, 'object');
-            this.assertType(this.env.sockethub.platforms.size, 'number');
-          }
-        }
-      ]
-    }
-  ];
-});