@azure/storage-blob-changefeed 12.0.0-alpha.20220413.1 → 12.0.0-alpha.20220419.3

package/CHANGELOG.md

@@ -1,7 +1,10 @@
 # Release History
 
-## 12.0.0-preview.3 (Unreleased)
+## 12.0.0-preview.3 (2022-04-19)
 
+### Features Added
+
+-Added support for event schema V3, V4, and V5.
 
 ## 12.0.0-preview.2 (2020-09-08)
 

package/dist/index.js

@@ -159,6 +159,87 @@ function minDate(dateA, dateB) {
     }
     return dateA;
 }
+function rawEventToBlobChangeFeedEvent(rawEvent) {
+    if (rawEvent.eventTime) {
+        rawEvent.eventTime = new Date(rawEvent.eventTime);
+    }
+    if (rawEvent.eTag) {
+        rawEvent.etag = rawEvent.eTag;
+        delete rawEvent.eTag;
+    }
+    if (rawEvent.data) {
+        if (rawEvent.data.recursive !== undefined) {
+            rawEvent.data.isRecursive = rawEvent.data.recursive;
+            delete rawEvent.data.recursive;
+        }
+        if (rawEvent.data.previousInfo) {
+            const previousInfo = rawEvent.data.previousInfo;
+            if (previousInfo.SoftDeleteSnapshot) {
+                previousInfo.softDeleteSnapshot = previousInfo.SoftDeleteSnapshot;
+                delete previousInfo.SoftDeleteSnapshot;
+            }
+            if (previousInfo.WasBlobSoftDeleted) {
+                previousInfo.isBlobSoftDeleted = previousInfo.WasBlobSoftDeleted === "true";
+                delete previousInfo.WasBlobSoftDeleted;
+            }
+            if (previousInfo.BlobVersion) {
+                previousInfo.newBlobVersion = previousInfo.BlobVersion;
+                delete previousInfo.BlobVersion;
+            }
+            if (previousInfo.LastVersion) {
+                previousInfo.oldBlobVersion = previousInfo.LastVersion;
+                delete previousInfo.LastVersion;
+            }
+            if (previousInfo.PreviousTier) {
+                previousInfo.previousTier = previousInfo.PreviousTier;
+                delete previousInfo.PreviousTier;
+            }
+            rawEvent.data.previousInfo = previousInfo;
+        }
+        if (rawEvent.data.blobPropertiesUpdated) {
+            const updatedBlobProperties = {};
+            Object.entries(rawEvent.data.blobPropertiesUpdated).map((item) => {
+                const blobPropertyChange = {
+                    propertyName: item[0],
+                    oldValue: item[1].previous,
+                    newValue: item[1].current,
+                };
+                updatedBlobProperties[item[0]] = blobPropertyChange;
+            });
+            rawEvent.data.updatedBlobProperties = updatedBlobProperties;
+            delete rawEvent.data.blobPropertiesUpdated;
+        }
+        if (rawEvent.data.asyncOperationInfo) {
+            const longRunningOperationInfo = rawEvent.data.asyncOperationInfo;
+            if (longRunningOperationInfo.DestinationTier) {
+                longRunningOperationInfo.destinationAccessTier = longRunningOperationInfo.DestinationTier;
+                delete longRunningOperationInfo.DestinationTier;
+            }
+            if ("WasAsyncOperation" in longRunningOperationInfo) {
+                longRunningOperationInfo.isAsync = longRunningOperationInfo.WasAsyncOperation === "true";
+                delete longRunningOperationInfo.WasAsyncOperation;
+            }
+            if (longRunningOperationInfo.CopyId) {
+                longRunningOperationInfo.copyId = longRunningOperationInfo.CopyId;
+                delete longRunningOperationInfo.CopyId;
+            }
+            rawEvent.data.longRunningOperationInfo = longRunningOperationInfo;
+            delete rawEvent.data.asyncOperationInfo;
+        }
+        if (rawEvent.data.blobTagsUpdated) {
+            rawEvent.data.updatedBlobTags = {
+                newTags: rawEvent.data.blobTagsUpdated.current,
+                oldTags: rawEvent.data.blobTagsUpdated.previous,
+            };
+            delete rawEvent.data.blobTagsUpdated;
+        }
+        if (rawEvent.data.blobTier) {
+            rawEvent.data.blobAccessTier = rawEvent.data.blobTier;
+            delete rawEvent.data.blobTier;
+        }
+    }
+    return rawEvent;
+}
 
 // Copyright (c) Microsoft Corporation.
 class ChangeFeed {
@@ -279,22 +360,6 @@ const AVRO_INIT_BYTES = new Uint8Array([79, 98, 106, 1]);
 const AVRO_CODEC_KEY = "avro.codec";
 const AVRO_SCHEMA_KEY = "avro.schema";
 
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-function arraysEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a == null || b == null)
-        return false;
-    if (a.length != b.length)
-        return false;
-    for (let i = 0; i < a.length; ++i) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
-}
-
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 class AvroParser {
@@ -307,7 +372,7 @@ class AvroParser {
      */
     static async readFixedBytes(stream, length, options = {}) {
         const bytes = await stream.read(length, { abortSignal: options.abortSignal });
-        if (bytes.length != length) {
+        if (bytes.length !== length) {
             throw new Error("Hit stream end.");
         }
         return bytes;
@@ -337,6 +402,7 @@ class AvroParser {
         } while (haveMoreByte && significanceInBit < 28); // bitwise operation only works for 32-bit integers
         if (haveMoreByte) {
             // Switch to float arithmetic
+            // eslint-disable-next-line no-self-assign
             zigZagEncoded = zigZagEncoded;
             significanceInFloat = 268435456; // 2 ** 28.
             do {
@@ -363,10 +429,10 @@ class AvroParser {
     }
     static async readBoolean(stream, options = {}) {
         const b = await AvroParser.readByte(stream, options);
-        if (b == 1) {
+        if (b === 1) {
             return true;
         }
-        else if (b == 0) {
+        else if (b === 0) {
             return false;
         }
         else {
@@ -388,16 +454,10 @@ class AvroParser {
         if (size < 0) {
             throw new Error("Bytes size was negative.");
         }
-        return await stream.read(size, { abortSignal: options.abortSignal });
+        return stream.read(size, { abortSignal: options.abortSignal });
     }
     static async readString(stream, options = {}) {
         const u8arr = await AvroParser.readBytes(stream, options);
-        // polyfill TextDecoder to be backward compatible with older
-        // nodejs that doesn't expose TextDecoder as a global variable
-        if (typeof TextDecoder === "undefined" && typeof require !== "undefined") {
-            global.TextDecoder = require("util").TextDecoder;
-        }
-        // FUTURE: need TextDecoder polyfill for IE
         const utf8decoder = new TextDecoder();
         return utf8decoder.decode(u8arr);
     }
@@ -408,8 +468,8 @@ class AvroParser {
         return { key, value };
     }
     static async readMap(stream, readItemMethod, options = {}) {
-        const readPairMethod = async (stream, options = {}) => {
-            return await AvroParser.readMapPair(stream, readItemMethod, options);
+        const readPairMethod = (s, opts = {}) => {
+            return AvroParser.readMapPair(s, readItemMethod, opts);
         };
         const pairs = await AvroParser.readArray(stream, readPairMethod, options);
         const dict = {};
@@ -420,7 +480,7 @@ class AvroParser {
     }
     static async readArray(stream, readItemMethod, options = {}) {
         const items = [];
-        for (let count = await AvroParser.readLong(stream, options); count != 0; count = await AvroParser.readLong(stream, options)) {
+        for (let count = await AvroParser.readLong(stream, options); count !== 0; count = await AvroParser.readLong(stream, options)) {
             if (count < 0) {
                 // Ignore block sizes
                 await AvroParser.readLong(stream, options);
@@ -443,6 +503,17 @@ var AvroComplex;
     AvroComplex["UNION"] = "union";
     AvroComplex["FIXED"] = "fixed";
 })(AvroComplex || (AvroComplex = {}));
+var AvroPrimitive;
+(function (AvroPrimitive) {
+    AvroPrimitive["NULL"] = "null";
+    AvroPrimitive["BOOLEAN"] = "boolean";
+    AvroPrimitive["INT"] = "int";
+    AvroPrimitive["LONG"] = "long";
+    AvroPrimitive["FLOAT"] = "float";
+    AvroPrimitive["DOUBLE"] = "double";
+    AvroPrimitive["BYTES"] = "bytes";
+    AvroPrimitive["STRING"] = "string";
+})(AvroPrimitive || (AvroPrimitive = {}));
 class AvroType {
     /**
      * Determines the AvroType from the Avro Schema.
@@ -482,7 +553,9 @@ class AvroType {
         try {
             return AvroType.fromStringSchema(type);
         }
-        catch (err) { }
+        catch (err) {
+            // eslint-disable-line no-empty
+        }
         switch (type) {
             case AvroComplex.RECORD:
                 if (schema.aliases) {
@@ -491,6 +564,7 @@ class AvroType {
                 if (!schema.name) {
                     throw new Error(`Required attribute 'name' doesn't exist on schema: ${schema}`);
                 }
+                // eslint-disable-next-line no-case-declarations
                 const fields = {};
                 if (!schema.fields) {
                     throw new Error(`Required attribute 'fields' doesn't exist on schema: ${schema}`);
@@ -519,40 +593,29 @@ class AvroType {
         }
     }
 }
-var AvroPrimitive;
-(function (AvroPrimitive) {
-    AvroPrimitive["NULL"] = "null";
-    AvroPrimitive["BOOLEAN"] = "boolean";
-    AvroPrimitive["INT"] = "int";
-    AvroPrimitive["LONG"] = "long";
-    AvroPrimitive["FLOAT"] = "float";
-    AvroPrimitive["DOUBLE"] = "double";
-    AvroPrimitive["BYTES"] = "bytes";
-    AvroPrimitive["STRING"] = "string";
-})(AvroPrimitive || (AvroPrimitive = {}));
 class AvroPrimitiveType extends AvroType {
     constructor(primitive) {
         super();
         this._primitive = primitive;
     }
-    async read(stream, options = {}) {
+    read(stream, options = {}) {
         switch (this._primitive) {
             case AvroPrimitive.NULL:
-                return await AvroParser.readNull();
+                return AvroParser.readNull();
             case AvroPrimitive.BOOLEAN:
-                return await AvroParser.readBoolean(stream, options);
+                return AvroParser.readBoolean(stream, options);
             case AvroPrimitive.INT:
-                return await AvroParser.readInt(stream, options);
+                return AvroParser.readInt(stream, options);
             case AvroPrimitive.LONG:
-                return await AvroParser.readLong(stream, options);
+                return AvroParser.readLong(stream, options);
             case AvroPrimitive.FLOAT:
-                return await AvroParser.readFloat(stream, options);
+                return AvroParser.readFloat(stream, options);
             case AvroPrimitive.DOUBLE:
-                return await AvroParser.readDouble(stream, options);
+                return AvroParser.readDouble(stream, options);
             case AvroPrimitive.BYTES:
-                return await AvroParser.readBytes(stream, options);
+                return AvroParser.readBytes(stream, options);
             case AvroPrimitive.STRING:
-                return await AvroParser.readString(stream, options);
+                return AvroParser.readString(stream, options);
             default:
                 throw new Error("Unknown Avro Primitive");
         }
@@ -575,7 +638,7 @@ class AvroUnionType extends AvroType {
     }
     async read(stream, options = {}) {
         const typeIndex = await AvroParser.readInt(stream, options);
-        return await this._types[typeIndex].read(stream, options);
+        return this._types[typeIndex].read(stream, options);
     }
 }
 class AvroMapType extends AvroType {
@@ -583,11 +646,11 @@ class AvroMapType extends AvroType {
         super();
         this._itemType = itemType;
     }
-    async read(stream, options = {}) {
-        const readItemMethod = async (s, options) => {
-            return await this._itemType.read(s, options);
+    read(stream, options = {}) {
+        const readItemMethod = (s, opts) => {
+            return this._itemType.read(s, opts);
         };
-        return await AvroParser.readMap(stream, readItemMethod, options);
+        return AvroParser.readMap(stream, readItemMethod, options);
     }
 }
 class AvroRecordType extends AvroType {
@@ -600,7 +663,7 @@ class AvroRecordType extends AvroType {
         const record = {};
         record["$schema"] = this._name;
         for (const key in this._fields) {
-            if (this._fields.hasOwnProperty(key)) {
+            if (Object.prototype.hasOwnProperty.call(this._fields, key)) {
                 record[key] = await this._fields[key].read(stream, options);
             }
         }
@@ -608,6 +671,23 @@ class AvroRecordType extends AvroType {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+function arraysEqual(a, b) {
+    if (a === b)
+        return true;
+    // eslint-disable-next-line eqeqeq
+    if (a == null || b == null)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; ++i) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+
 // Copyright (c) Microsoft Corporation.
 class AvroReader {
     constructor(dataStream, headerStream, currentBlockOffset, indexWithinCurrentBlock) {
@@ -638,7 +718,7 @@ class AvroReader {
         });
         // Validate codec
         const codec = this._metadata[AVRO_CODEC_KEY];
-        if (!(codec == undefined || codec == "null")) {
+        if (!(codec === undefined || codec === null || codec === "null")) {
             throw new Error("Codecs are not supported");
         }
         // The 16-byte, randomly-generated sync marker for this file.
@@ -648,7 +728,7 @@ class AvroReader {
         // Parse the schema
         const schema = JSON.parse(this._metadata[AVRO_SCHEMA_KEY]);
         this._itemType = AvroType.fromSchema(schema);
-        if (this._blockOffset == 0) {
+        if (this._blockOffset === 0) {
             this._blockOffset = this._initialBlockOffset + this._dataStream.position;
         }
         this._itemsRemainingInBlock = await AvroParser.readLong(this._dataStream, {
@@ -678,7 +758,7 @@ class AvroReader {
                 }));
                 this._itemsRemainingInBlock--;
                 this._objectIndex++;
-                if (this._itemsRemainingInBlock == 0) {
+                if (this._itemsRemainingInBlock === 0) {
                     const marker = yield tslib.__await(AvroParser.readFixedBytes(this._dataStream, AVRO_SYNC_MARKER_SIZE, {
                         abortSignal: options.abortSignal,
                     }));
@@ -753,6 +833,7 @@ class AvroReadableFromStream extends AvroReadable {
         else {
             // register callback to wait for enough data to read
             return new Promise((resolve, reject) => {
+                /* eslint-disable @typescript-eslint/no-use-before-define */
                 const cleanUp = () => {
                     this._readable.removeListener("readable", readableCallback);
                     this._readable.removeListener("error", rejectCallback);
@@ -763,12 +844,12 @@ class AvroReadableFromStream extends AvroReadable {
                     }
                 };
                 const readableCallback = () => {
-                    const chunk = this._readable.read(size);
-                    if (chunk) {
-                        this._position += chunk.length;
+                    const callbackChunk = this._readable.read(size);
+                    if (callbackChunk) {
+                        this._position += callbackChunk.length;
                         cleanUp();
-                        // chunk.length maybe less than desired size if the stream ends.
-                        resolve(this.toUint8Array(chunk));
+                        // callbackChunk.length maybe less than desired size if the stream ends.
+                        resolve(this.toUint8Array(callbackChunk));
                     }
                 };
                 const rejectCallback = () => {
@@ -786,6 +867,7 @@ class AvroReadableFromStream extends AvroReadable {
                 if (options.abortSignal) {
                     options.abortSignal.addEventListener("abort", abortHandler);
                 }
+                /* eslint-enable @typescript-eslint/no-use-before-define */
             });
         }
     }
@@ -1061,7 +1143,6 @@ class ShardFactory {
 }
 
 // Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
 class Chunk {
     constructor(avroReader, blockOffset, eventIndex, chunkPath, avroOptions = {}) {
         this.chunkPath = chunkPath;
@@ -1094,14 +1175,7 @@ class Chunk {
             if (eventRaw === null) {
                 return undefined;
             }
-            if (eventRaw.eventTime) {
-                eventRaw.eventTime = new Date(eventRaw.eventTime);
-            }
-            if (eventRaw.eTag) {
-                eventRaw.etag = eventRaw.eTag;
-                delete eventRaw.eTag;
-            }
-            return eventRaw;
+            return rawEventToBlobChangeFeedEvent(eventRaw);
         }
     }
 }