Add support for TypedDataCollections (#263)

* Add support for TypedDataCollection

* change package updates for a separate pr

* make change only for v3 functions host +

Author: mhoeger

package-lock.json

@@ -110,11 +110,15 @@ export class WorkerChannel implements IWorkerChannel {
       }
     }
 
-    const workerCapabilities = {
+    let workerCapabilities = {
       RpcHttpTriggerMetadataRemoved: "true",
       RpcHttpBodyOnly: "true"
     };
 
+    if (!this._v1WorkerBehavior) {
+      workerCapabilities["TypedDataCollection"] = "true";
+    }
+
     this._eventStream.write({
       requestId: requestId,
       workerInitResponse: {

src/WorkerChannel.ts

@@ -7,6 +7,7 @@ import {
 } from '../../azure-functions-language-worker-protobuf/src/rpc';
 import { InternalException } from "../utils/InternalException";
 import { TraceContext } from '../public/Interfaces';
+import { isLong } from 'long'
 
 /**
  * Converts 'ITypedData' input from the RPC layer to JavaScript types.
@@ -28,6 +29,16 @@ export function fromTypedData(typedData?: rpc.ITypedData, convertStringToJson: b
         return str;
     } else if (typedData.bytes) {
         return Buffer.from(<Buffer>typedData.bytes);
+    } else if (typedData.collectionBytes && typedData.collectionBytes.bytes) {
+        let byteCollection = <Uint8Array[]>typedData.collectionBytes.bytes;
+        return byteCollection.map(element => Buffer.from(<Buffer>element));
+    } else if (typedData.collectionString && typedData.collectionString.string) {
+        return <string[]>typedData.collectionString.string;
+    } else if (typedData.collectionDouble && typedData.collectionDouble.double) {
+        return <number[]>typedData.collectionDouble.double;
+    } else if (typedData.collectionSint64 && typedData.collectionSint64.sint64) {
+        let longCollection = <(Long|number)[]>typedData.collectionSint64.sint64;
+        return longCollection.map(element => isLong(element) ? element.toString() : <number>element);
     }
 }
 

src/converters/RpcConverters.ts

@@ -1,9 +1,10 @@
-import { getNormalizedBindingData, toRpcHttp, getBindingDefinitions } from '../src/converters';
+import { getNormalizedBindingData, toRpcHttp, getBindingDefinitions, fromTypedData } from '../src/converters';
 import { FunctionInfo } from '../src/FunctionInfo';
 import { expect } from 'chai';
 import * as sinon from 'sinon';
 import { AzureFunctionsRpcMessages as rpc } from '../azure-functions-language-worker-protobuf/src/rpc';
 import 'mocha';
+import { fromString } from 'long';
 
 describe('Binding Converters', () => {
   it('normalizes binding trigger metadata for HTTP', () => {
@@ -127,4 +128,46 @@ describe('Binding Converters', () => {
     expect(bindingDefinitions[3].direction).to.be.undefined;
     expect(bindingDefinitions[3].type).to.equal("queue");
   });
+
+  it('deserializes string data with fromTypedData', () => {
+    let data = fromTypedData({ string: "foo" });
+    expect(data).to.equal("foo");
+  });
+
+  it('deserializes json data with fromTypedData', () => {
+    let data = fromTypedData({ json: "\{ \"foo\": \"bar\" }" });
+    expect(data && data["foo"]).to.equal("bar");
+  });
+
+  it('deserializes byte data with fromTypedData', () => {
+    let buffer = Buffer.from("hello");
+    let data = fromTypedData({ bytes: buffer });
+    expect(data && data["buffer"]).to.equal(buffer.buffer);
+  });
+
+  it('deserializes collectionBytes data with fromTypedData', () => {
+    let fooBuffer = Buffer.from("foo");
+    let barBuffer = Buffer.from("bar");
+    let data = fromTypedData({ collectionBytes: { bytes: [fooBuffer, barBuffer] } });
+    expect(data && data[0] && data[0]["buffer"]).to.equal(fooBuffer.buffer);
+    expect(data && data[1] && data[1]["buffer"]).to.equal(barBuffer.buffer);
+  });
+
+  it('deserializes collectionString data with fromTypedData', () => {
+    let data = fromTypedData({ collectionString: { string: ["foo", "bar"] } });
+    expect(data && data[0]).to.equal("foo");
+    expect(data && data[1]).to.equal("bar");
+  });
+
+  it('deserializes collectionDouble data with fromTypedData', () => {
+    let data = fromTypedData({ collectionDouble: { double: [1.1, 2.2] } });
+    expect(data && data[0]).to.equal(1.1);
+    expect(data && data[1]).to.equal(2.2);
+  });
+
+  it('deserializes collectionSint64 data with fromTypedData', () => {
+    let data = fromTypedData({ collectionSint64: { sint64: [123, fromString("9007199254740992")] } });
+    expect(data && data[0]).to.equal(123);
+    expect(data && data[1]).to.equal("9007199254740992");
+  });
 })

test/BindingConvertersTests.ts

@@ -79,24 +79,29 @@ describe('WorkerChannel', () => {
       }
     };
 
-    // Test Functions Host V2 compatability with Node.js 8
-    if (process.version.startsWith("v8")) {
-      initMessage.workerInitRequest.capabilities["V2Compatable"] = "true";
-    }
-    
-    stream.addTestMessage(initMessage);
-    sinon.assert.calledWith(stream.written, <rpc.IStreamingMessage>{
+    let expectedOutput = {
       requestId: 'id',
       workerInitResponse: {
         capabilities: { 
-              'RpcHttpBodyOnly': "true",
-              'RpcHttpTriggerMetadataRemoved': "true"
+              'RpcHttpBodyOnly': 'true',
+              'RpcHttpTriggerMetadataRemoved': 'true'
         },
         result: {
           status: rpc.StatusResult.Status.Success
         }
       }
-    });
+    }
+
+    // V1 worker behavior
+    if (process.version.startsWith('v8')) {
+      initMessage.workerInitRequest.capabilities['V2Compatable'] = 'true';
+    // Expect this behavior in V2 worker behavior
+    } else {
+      expectedOutput.workerInitResponse.capabilities['TypedDataCollection'] = 'true';
+    }
+    
+    stream.addTestMessage(initMessage);
+    sinon.assert.calledWith(stream.written, );
   });
 
   it('responds to function load', () => {