Remove @types node dev dependency from botframework-streaming

libraries/botframework-streaming/src/index.ts

@@ -12,6 +12,7 @@ export {
     INodeBuffer,
     INodeIncomingMessage,
     INodeSocket,
+    INodeSocket2,
     IReceiveRequest,
     IReceiveResponse,
     ISocket,

libraries/botframework-streaming/src/interfaces/INodeSocket.ts

@@ -12,6 +12,7 @@
  * This interface supports the framework and is not intended to be called directly for your code.
  */
 export interface INodeSocket {
+    connecting: boolean;
     writable: boolean;
     write(str: string, cb?: Function): boolean;
     destroy(error?: Error): void;

libraries/botframework-streaming/src/interfaces/INodeSocket2.ts

@@ -0,0 +1,31 @@
+/**
+ * @module botframework-streaming
+ */
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Represents a Socket from the `net` module in Node.js.
+ * 
+ * This interface supports the framework and is not intended to be called directly for your code.
+ */
+export interface INodeSocket2 {
+    connecting: boolean;
+    destroyed: boolean;
+    writable: boolean;
+
+    end(str: string, cb?: Function): void;
+    destroy(error?: Error): void;
+
+    on(event: string, listener: (...args: any[]) => void): this;
+    on(event: "close", listener: (had_error: boolean) => void): this;
+    on(event: "connect", listener: () => void): this;
+    on(event: "data", listener: (data: Buffer) => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+
+    write(buffer: Buffer, cb?: Function): boolean;
+    write(str: string, cb?: Function): boolean;
+}

libraries/botframework-streaming/src/interfaces/index.ts

@@ -11,6 +11,7 @@ export * from './IBrowserWebSocket';
 export * from './INodeBuffer';
 export * from './INodeIncomingMessage';
 export * from './INodeSocket';
+export * from './INodeSocket2';
 export * from './IReceiveRequest';
 export * from './IReceiveResponse';
 export * from './ISocket';

libraries/botframework-streaming/src/namedPipe/namedPipeServer.ts

@@ -5,7 +5,7 @@
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-import { Server, Socket } from 'net';
+// import { Socket, Server } from 'net';
 import { ProtocolAdapter } from '../protocolAdapter';
 import { RequestHandler } from '../requestHandler';
 import { StreamingRequest } from '../streamingRequest';
@@ -15,14 +15,15 @@ import {
     PayloadSender
 } from '../payloadTransport';
 import { NamedPipeTransport } from './namedPipeTransport';
-import { IStreamingTransportServer, IReceiveResponse } from '../interfaces';
+import { INodeSocket2, IStreamingTransportServer, IReceiveResponse } from '../interfaces';
+import { createNodeServer } from '../utilities';
 
 /**
 * Streaming transport server implementation that uses named pipes for inter-process communication.
 */
 export class NamedPipeServer implements IStreamingTransportServer {
-    private _outgoingServer: Server;
-    private _incomingServer: Server;
+    private _outgoingServer
+    private _incomingServer
     private readonly _baseName: string;
     private readonly _requestHandler: RequestHandler;
     private readonly _sender: PayloadSender;
@@ -73,14 +74,15 @@ export class NamedPipeServer implements IStreamingTransportServer {
         }
 
         const incoming = new Promise(resolve => {
-            this._incomingServer = new Server((socket: Socket): void => {
-                this._receiver.connect(new NamedPipeTransport(socket));
-                resolve();
-            });
+                this._incomingServer =  createNodeServer((socket: INodeSocket2): void => {
+                    this._receiver.connect(new NamedPipeTransport(socket));
+                    resolve();
+                });
+
         });
 
         const outgoing = new Promise(resolve => {
-            this._outgoingServer = new Server((socket: Socket): void => {
+            this._outgoingServer = createNodeServer((socket: INodeSocket2): void => {
                 this._sender.connect(new NamedPipeTransport(socket));
                 resolve();
             });

libraries/botframework-streaming/src/namedPipe/namedPipeTransport.ts

@@ -5,11 +5,12 @@
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-import { Socket } from 'net';
+// import { Socket } from 'net';
+import { INodeSocket2 } from '../interfaces/INodeSocket2';
 import { ITransportSender } from '../interfaces/ITransportSender';
 import { ITransportReceiver } from '../interfaces/ITransportReceiver';
 
-
+// const testSocket = new Socket();
 /**
  * Named pipes based transport sender and receiver abstraction
  */
@@ -18,7 +19,7 @@ export class NamedPipeTransport implements ITransportSender, ITransportReceiver
     public static readonly ServerIncomingPath: string = '.incoming';
     public static readonly ServerOutgoingPath: string = '.outgoing';
 
-    private _socket: Socket;
+    private _socket: INodeSocket2;
     private readonly _queue: Buffer[];
     private _active: Buffer;
     private _activeOffset: number;
@@ -31,7 +32,7 @@ export class NamedPipeTransport implements ITransportSender, ITransportReceiver
      *
      * @param socket The socket object to build this connection on.
      */
-    public constructor(socket: Socket) {
+    public constructor(socket: INodeSocket2) {
         this._socket = socket;
         this._queue = [];
         this._activeOffset = 0;

libraries/botframework-streaming/src/utilities/createNodeServer.ts

@@ -0,0 +1,30 @@
+import { INodeSocket2 } from "../interfaces/INodeSocket2";
+
+/**
+ * @module botframework-streaming
+ */
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+ // What type hint should I put, if not importing 'net'?
+export const createNodeServer = function(callback?: (socket: INodeSocket2) => void) {
+    if (callback && typeof callback !== 'function') {
+        throw new TypeError(`Invalid callback; callback parameter must be a function to create Node 'net' Server.`);
+    }
+
+    return getNetServerConstructor()(callback);
+}
+
+export const getNetServerConstructor = function() {
+    if (typeof require !== undefined) {
+        return require('net').Server;
+    }
+
+    throw TypeError(`require is undefined. Must be in a Node module to require 'net' dynamically in order to fetch Server constructor.`)
+}
+
+// require is NOT globally defined, therefore Function() cannot access require() 
+// https://stackoverflow.com/questions/51164425/require-inside-new-function
+// export const getNetServerConstructor = new Function(`if (typeof require !== undefined) { return require('net').Server; } throw new Error('Not in a Node environment. Must use Node in order to create a Node Server.')`);

libraries/botframework-streaming/src/utilities/index.ts

@@ -8,4 +8,5 @@
 
 export * from './doesGlobalFileReaderExist';
 export * from './doesGlobalWebSocketExist';
+export * from './createNodeServer';
 export * from './protocol-base';

libraries/botframework-streaming/tests/NamedPipe.test.js

@@ -1,6 +1,7 @@
 const net = require('net');
 const np = require('../lib');
 const npt = require('../lib/namedPipe/namedPipeTransport');
+const NodeServerUtils = require('../lib/utilities/createNodeServer');
 const protocol = require('../lib');
 const  chai  = require('chai');
 var expect = chai.expect;
@@ -414,5 +415,29 @@ describe('Streaming Extensions NamedPipe Library Tests', () => {
             expect(server.disconnect()).to.not.throw;
             done();
         });
+
+
+        it('calling createNodeServer() should throw if passing in a callback that\'s not a function', () => {
+            const stringCallback = 'Not a real callback function.';
+            expect(() => NodeServerUtils.createNodeServer(stringCallback)).to.throw;
+        });
+
+        it('should not throw when choosing not to pass in a callback at all into createNodeServer()', () => {
+            expect(() => NodeServerUtils.createNodeServer()).to.not.throw;
+        });
+
+        it('should return a Server when calling createNodeServer()', () => {
+            const server = NodeServerUtils.createNodeServer();
+
+            expect(server).to.not.be.null;
+            expect(server).to.be.instanceOf(Object);
+        });
+
+        it('should return the constructor when calling getNodeServerConstructor()', () => {
+            const netServerCtor = NodeServerUtils.getNetServerConstructor();
+
+            expect(netServerCtor).to.not.be.null;
+            expect(typeof netServerCtor).to.equal('function');
+        });
     });
 });