@fluidframework/driver-utils 2.0.0-internal.5.1.1 → 2.0.0-internal.5.3.0

package/lib/adapters/compression/documentServiceCompressionAdapter.js

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { DocumentServiceProxy } from "../../documentServiceProxy";
+import { DocumentStorageServiceCompressionAdapter as DocumentStorageServiceSummaryBlobCompressionAdapter } from "./summaryblob";
+export class DocumentServiceCompressionAdapter extends DocumentServiceProxy {
+    constructor(service, _config) {
+        super(service);
+        this._config = _config;
+    }
+    async connectToStorage() {
+        const storage = await super.connectToStorage();
+        const wrapped = new DocumentStorageServiceSummaryBlobCompressionAdapter(storage, this._config);
+        await wrapped.getSnapshotTree();
+        return wrapped;
+    }
+}
+//# sourceMappingURL=documentServiceCompressionAdapter.js.map

package/lib/adapters/compression/documentServiceCompressionAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentServiceCompressionAdapter.js","sourceRoot":"","sources":["../../../src/adapters/compression/documentServiceCompressionAdapter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAE,wCAAwC,IAAI,mDAAmD,EAAE,MAAM,eAAe,CAAC;AAGhI,MAAM,OAAO,iCAAkC,SAAQ,oBAAoB;IAC1E,YAAY,OAAyB,EAAmB,OAAkC;QACzF,KAAK,CAAC,OAAO,CAAC,CAAC;QADwC,YAAO,GAAP,OAAO,CAA2B;IAE1F,CAAC;IAEM,KAAK,CAAC,gBAAgB;QAC5B,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,gBAAgB,EAAE,CAAC;QAC/C,MAAM,OAAO,GAAG,IAAI,mDAAmD,CACtE,OAAO,EACP,IAAI,CAAC,OAAO,CACZ,CAAC;QACF,MAAM,OAAO,CAAC,eAAe,EAAE,CAAC;QAChC,OAAO,OAAO,CAAC;IAChB,CAAC;CACD","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IDocumentService, IDocumentStorageService } from \"@fluidframework/driver-definitions\";\nimport { DocumentServiceProxy } from \"../../documentServiceProxy\";\nimport { DocumentStorageServiceCompressionAdapter as DocumentStorageServiceSummaryBlobCompressionAdapter } from \"./summaryblob\";\nimport { ICompressionStorageConfig } from \"./compressionTypes\";\n\nexport class DocumentServiceCompressionAdapter extends DocumentServiceProxy {\n\tconstructor(service: IDocumentService, private readonly _config: ICompressionStorageConfig) {\n\t\tsuper(service);\n\t}\n\n\tpublic async connectToStorage(): Promise<IDocumentStorageService> {\n\t\tconst storage = await super.connectToStorage();\n\t\tconst wrapped = new DocumentStorageServiceSummaryBlobCompressionAdapter(\n\t\t\tstorage,\n\t\t\tthis._config,\n\t\t);\n\t\tawait wrapped.getSnapshotTree();\n\t\treturn wrapped;\n\t}\n}\n"]}

package/lib/adapters/compression/documentServiceFactoryCompressionAdapter.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { IDocumentService, IDocumentServiceFactory, IResolvedUrl } from "@fluidframework/driver-definitions";
+import { ISummaryTree } from "@fluidframework/protocol-definitions";
+import { DocumentServiceFactoryProxy } from "../../documentServiceFactoryProxy";
+import { ICompressionStorageConfig } from "..";
+export declare class DocumentServiceFactoryCompressionAdapter extends DocumentServiceFactoryProxy {
+    private readonly _config;
+    constructor(serviceFactory: IDocumentServiceFactory, _config: ICompressionStorageConfig);
+    createContainer(createNewSummary: ISummaryTree | undefined, createNewResolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
+    createDocumentService(resolvedUrl: IResolvedUrl): Promise<IDocumentService>;
+}
+//# sourceMappingURL=documentServiceFactoryCompressionAdapter.d.ts.map

package/lib/adapters/compression/documentServiceFactoryCompressionAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentServiceFactoryCompressionAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/compression/documentServiceFactoryCompressionAdapter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EACN,gBAAgB,EAChB,uBAAuB,EACvB,YAAY,EACZ,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AACpE,OAAO,EAAE,2BAA2B,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAE,yBAAyB,EAAE,MAAM,IAAI,CAAC;AAI/C,qBAAa,wCAAyC,SAAQ,2BAA2B;IAGvF,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADxB,cAAc,EAAE,uBAAuB,EACtB,OAAO,EAAE,yBAAyB;IAKvC,eAAe,CAC3B,gBAAgB,EAAE,YAAY,GAAG,SAAS,EAC1C,oBAAoB,EAAE,YAAY,EAClC,MAAM,CAAC,EAAE,oBAAoB,EAC7B,kBAAkB,CAAC,EAAE,OAAO,GAC1B,OAAO,CAAC,gBAAgB,CAAC;IA2Bf,qBAAqB,CAAC,WAAW,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAIxF"}

package/lib/adapters/compression/documentServiceFactoryCompressionAdapter.js

@@ -0,0 +1,32 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { DocumentServiceFactoryProxy } from "../../documentServiceFactoryProxy";
+import { DocumentStorageServiceCompressionAdapter as DocumentStorageServiceSummaryBlobCompressionAdapter } from "./summaryblob";
+import { DocumentServiceCompressionAdapter } from "./documentServiceCompressionAdapter";
+export class DocumentServiceFactoryCompressionAdapter extends DocumentServiceFactoryProxy {
+    constructor(serviceFactory, _config) {
+        super(serviceFactory);
+        this._config = _config;
+    }
+    async createContainer(createNewSummary, createNewResolvedUrl, logger, clientIsSummarizer) {
+        if (createNewSummary !== undefined) {
+            // TODO : this is a hack to make sure that the initial summary is not compressed
+            // We must prevent the initial summary from being compressed because
+            // of the hack at packages/drivers/routerlicious-driver/src/createNewUtils.ts
+            // where the binary blob is converted to a string using UTF-8 encoding
+            // which is producing incorrect results for compressed data.
+            const configForInitial = Object.assign(Object.assign({}, this._config), { minSizeToCompress: Number.POSITIVE_INFINITY });
+            const newAppSumary = DocumentStorageServiceSummaryBlobCompressionAdapter.compressSummary(createNewSummary.tree[".app"], configForInitial);
+            createNewSummary.tree[".app"] = newAppSumary;
+        }
+        const service = await this.serviceFactory.createContainer(createNewSummary, createNewResolvedUrl, logger, clientIsSummarizer);
+        return new DocumentServiceCompressionAdapter(service, this._config);
+    }
+    async createDocumentService(resolvedUrl) {
+        const service = await this.serviceFactory.createDocumentService(resolvedUrl);
+        return new DocumentServiceCompressionAdapter(service, this._config);
+    }
+}
+//# sourceMappingURL=documentServiceFactoryCompressionAdapter.js.map

package/lib/adapters/compression/documentServiceFactoryCompressionAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentServiceFactoryCompressionAdapter.js","sourceRoot":"","sources":["../../../src/adapters/compression/documentServiceFactoryCompressionAdapter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,EAAE,2BAA2B,EAAE,MAAM,mCAAmC,CAAC;AAEhF,OAAO,EAAE,wCAAwC,IAAI,mDAAmD,EAAE,MAAM,eAAe,CAAC;AAChI,OAAO,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC;AAExF,MAAM,OAAO,wCAAyC,SAAQ,2BAA2B;IACxF,YACC,cAAuC,EACtB,OAAkC;QAEnD,KAAK,CAAC,cAAc,CAAC,CAAC;QAFL,YAAO,GAAP,OAAO,CAA2B;IAGpD,CAAC;IAEM,KAAK,CAAC,eAAe,CAC3B,gBAA0C,EAC1C,oBAAkC,EAClC,MAA6B,EAC7B,kBAA4B;QAE5B,IAAI,gBAAgB,KAAK,SAAS,EAAE;YACnC,gFAAgF;YAChF,oEAAoE;YACpE,6EAA6E;YAC7E,sEAAsE;YACtE,4DAA4D;YAC5D,MAAM,gBAAgB,mCAClB,IAAI,CAAC,OAAO,KACf,iBAAiB,EAAE,MAAM,CAAC,iBAAiB,GAC3C,CAAC;YACF,MAAM,YAAY,GACjB,mDAAmD,CAAC,eAAe,CAClE,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAiB,EAC7C,gBAAgB,CAChB,CAAC;YACH,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC;SAC7C;QACD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,eAAe,CACxD,gBAAgB,EAChB,oBAAoB,EACpB,MAAM,EACN,kBAAkB,CAClB,CAAC;QACF,OAAO,IAAI,iCAAiC,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACrE,CAAC;IAEM,KAAK,CAAC,qBAAqB,CAAC,WAAyB;QAC3D,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;QAC7E,OAAO,IAAI,iCAAiC,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACrE,CAAC;CACD","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ITelemetryBaseLogger } from \"@fluidframework/core-interfaces\";\nimport {\n\tIDocumentService,\n\tIDocumentServiceFactory,\n\tIResolvedUrl,\n} from \"@fluidframework/driver-definitions\";\nimport { ISummaryTree } from \"@fluidframework/protocol-definitions\";\nimport { DocumentServiceFactoryProxy } from \"../../documentServiceFactoryProxy\";\nimport { ICompressionStorageConfig } from \"..\";\nimport { DocumentStorageServiceCompressionAdapter as DocumentStorageServiceSummaryBlobCompressionAdapter } from \"./summaryblob\";\nimport { DocumentServiceCompressionAdapter } from \"./documentServiceCompressionAdapter\";\n\nexport class DocumentServiceFactoryCompressionAdapter extends DocumentServiceFactoryProxy {\n\tconstructor(\n\t\tserviceFactory: IDocumentServiceFactory,\n\t\tprivate readonly _config: ICompressionStorageConfig,\n\t) {\n\t\tsuper(serviceFactory);\n\t}\n\n\tpublic async createContainer(\n\t\tcreateNewSummary: ISummaryTree | undefined,\n\t\tcreateNewResolvedUrl: IResolvedUrl,\n\t\tlogger?: ITelemetryBaseLogger,\n\t\tclientIsSummarizer?: boolean,\n\t): Promise<IDocumentService> {\n\t\tif (createNewSummary !== undefined) {\n\t\t\t// TODO : this is a hack to make sure that the initial summary is not compressed\n\t\t\t// We must prevent the initial summary from being compressed because\n\t\t\t// of the hack at packages/drivers/routerlicious-driver/src/createNewUtils.ts\n\t\t\t// where the binary blob is converted to a string using UTF-8 encoding\n\t\t\t// which is producing incorrect results for compressed data.\n\t\t\tconst configForInitial = {\n\t\t\t\t...this._config,\n\t\t\t\tminSizeToCompress: Number.POSITIVE_INFINITY,\n\t\t\t};\n\t\t\tconst newAppSumary =\n\t\t\t\tDocumentStorageServiceSummaryBlobCompressionAdapter.compressSummary(\n\t\t\t\t\tcreateNewSummary.tree[\".app\"] as ISummaryTree,\n\t\t\t\t\tconfigForInitial,\n\t\t\t\t);\n\t\t\tcreateNewSummary.tree[\".app\"] = newAppSumary;\n\t\t}\n\t\tconst service = await this.serviceFactory.createContainer(\n\t\t\tcreateNewSummary,\n\t\t\tcreateNewResolvedUrl,\n\t\t\tlogger,\n\t\t\tclientIsSummarizer,\n\t\t);\n\t\treturn new DocumentServiceCompressionAdapter(service, this._config);\n\t}\n\n\tpublic async createDocumentService(resolvedUrl: IResolvedUrl): Promise<IDocumentService> {\n\t\tconst service = await this.serviceFactory.createDocumentService(resolvedUrl);\n\t\treturn new DocumentServiceCompressionAdapter(service, this._config);\n\t}\n}\n"]}

package/lib/adapters/compression/index.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { SummaryCompressionAlgorithm, ICompressionStorageConfig, DefaultCompressionStorageConfig, } from "./compressionTypes";
+export { DocumentServiceFactoryCompressionAdapter } from "./documentServiceFactoryCompressionAdapter";
+export { blobHeadersBlobName } from "./summaryblob";
+//# sourceMappingURL=index.d.ts.map

package/lib/adapters/compression/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/compression/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,2BAA2B,EAC3B,yBAAyB,EACzB,+BAA+B,GAC/B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,wCAAwC,EAAE,MAAM,4CAA4C,CAAC;AACtG,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC"}

package/lib/adapters/compression/index.js

@@ -0,0 +1,8 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { SummaryCompressionAlgorithm, DefaultCompressionStorageConfig, } from "./compressionTypes";
+export { DocumentServiceFactoryCompressionAdapter } from "./documentServiceFactoryCompressionAdapter";
+export { blobHeadersBlobName } from "./summaryblob";
+//# sourceMappingURL=index.js.map

package/lib/adapters/compression/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/adapters/compression/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,2BAA2B,EAE3B,+BAA+B,GAC/B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,wCAAwC,EAAE,MAAM,4CAA4C,CAAC;AACtG,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport {\n\tSummaryCompressionAlgorithm,\n\tICompressionStorageConfig,\n\tDefaultCompressionStorageConfig,\n} from \"./compressionTypes\";\nexport { DocumentServiceFactoryCompressionAdapter } from \"./documentServiceFactoryCompressionAdapter\";\nexport { blobHeadersBlobName } from \"./summaryblob\";\n"]}

package/lib/adapters/compression/summaryblob/documentStorageServiceSummaryBlobCompressionAdapter.d.ts

@@ -0,0 +1,161 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { IDocumentStorageService, ISummaryContext } from "@fluidframework/driver-definitions";
+import { ISnapshotTree, ISummaryHandle, ISummaryTree, IVersion } from "@fluidframework/protocol-definitions";
+import { DocumentStorageServiceProxy } from "../../../documentStorageServiceProxy";
+import { ICompressionStorageConfig } from "../";
+export declare const blobHeadersBlobName = ".metadata.blobHeaders";
+/**
+ * This class is a proxy for the IDocumentStorageService that compresses and decompresses blobs in the summary.
+ * The identification of the compressed blobs is done by adding a compression markup blob to the summary.
+ * Even if the markup blob is present, it does not mean that all blobs are compressed. The blob,
+ * which is compressed also contain the compression algorithm enumerated value from the
+ * SummaryCompressionAlgorithm enumeration in the first byte . If the blob is not
+ * commpressed, it contains the first byte equals to SummaryCompressionAlgorithm.None .
+ * In case, the markup blob is present, it is expected that the first byte of the markup blob
+ * will contain the info about the compression. If the first byte is not present, it is assumed
+ * that the compression is not enabled and no first prefix byte is present in the blobs.
+ */
+export declare class DocumentStorageServiceCompressionAdapter extends DocumentStorageServiceProxy {
+    private readonly _config;
+    private _isCompressionEnabled;
+    constructor(service: IDocumentStorageService, _config: ICompressionStorageConfig);
+    get service(): IDocumentStorageService;
+    /**
+     * This method returns true if there is a compression markup byte in the blob, otherwise false.
+     * @param blob - The blob to compress.
+     * @returns - True if there is a compression markup byte in the blob, otherwise false.
+     */
+    private static hasPrefix;
+    /**
+     * This method reads the first byte from the given blob and maps that byte to the compression algorithm.
+     * @param blob - The maybe compressed blob.
+     */
+    private static readAlgorithmFromBlob;
+    /**
+     * This method writes the given algorithm to the blob as the first byte.
+     * @param blob - The blob to write the algorithm to.
+     * @param algorithm - The algorithm to write.
+     * @returns - The blob with the algorithm as the first byte.
+     */
+    private static writeAlgorithmToBlob;
+    /**
+     * This method removes the algorithm markup prefix from the blob (1 byte)
+     * @param blob - The blob to remove the prefix from.
+     * @returns - The blob without the prefix.
+     */
+    private static removePrefixFromBlobIfPresent;
+    /**
+     * This method converts the given argument to Uint8Array. If the parameter is already Uint8Array,
+     * it is just returned as is. If the parameter is string, it is converted to Uint8Array using
+     * TextEncoder.
+     * @param input - The input to convert to Uint8Array.
+     * @returns - The Uint8Array representation of the input.
+     */
+    private static toBinaryArray;
+    /**
+     * This method encodes the blob inside the given summary object of the SummaryType.Blob type using the given config
+     * containing  the compression algorithm.
+     * @param input - The summary object to encode.
+     * @param config - The config containing the compression algorithm.
+     * @returns - The summary object with the encoded blob.
+     */
+    private static readonly blobEncoder;
+    /**
+     * This method decodes the blob inside the given summary object of the SummaryType.Blob type.
+     * @param input - The summary object to decode.
+     * @returns - The summary object with the decoded blob.
+     */
+    private static readonly blobDecoder;
+    /**
+     * This method encodes the given blob according to the given config.
+     * @param file - The blob to encode.
+     * @param config - The config to use for encoding.
+     * @returns - The encoded blob.
+     */
+    private static encodeBlob;
+    /**
+     * This method decodes the given blob.
+     * @param file - The blob to decode.
+     * @returns - The decoded blob.
+     */
+    private static decodeBlob;
+    /**
+     * This method traverses the SummaryObject recursively. If it finds the ISummaryBlob object,
+     * it applies encoding/decoding on it according to the given isEncode flag.
+     * @param isEncode - True if the encoding should be applied, false if the decoding should be applied.
+     * @param input - The summary object to traverse.
+     * @param encoder - The encoder function to use.
+     * @param decoder - The decoder function to use.
+     * @param config - The config to use for encoding.
+     * @param context - The summary context.
+     * @returns - The summary object with the encoded/decoded blob.
+     */
+    private static recursivelyReplace;
+    /**
+     * This method traverses the SummaryTree recursively. If it finds the ISummaryBlob object with the key '.metadata',
+     * it returns the summary tree containing that blob.
+     *
+     * @param summary - The summary tree to traverse.
+     * @returns - The summary tree containing the metadata blob.
+     */
+    private static findMetadataHolderSummary;
+    /**
+     * This method obtains the summary tree containing the metadata blob. It returns the content
+     * of the tree atribute.
+     * @param summary - The summary tree to traverse.
+     * @returns - The content of the tree attribute of the summary tree containing the metadata blob.
+     */
+    private static getMetadataHolderTree;
+    /**
+     * This method adds the compression markup blob to the nested summary tree containing the metadata blob.
+     * @param summary - The top summary tree to put the compression markup blob into.
+     */
+    private static putCompressionMarkup;
+    /**
+     * This method traverses the SnapshotTree recursively. If it finds the ISummaryBlob object with the key '.metadata',
+     * it checks, if the SummaryTree holder of that object also contains the compression markup blob. If it is found,
+     * it returns true, otherwise false.
+     * @param snapshot - The snapshot tree to traverse.
+     * @returns - True if the compression markup blob is found, otherwise false.
+     */
+    private static hasCompressionMarkup;
+    /**
+     * This method performs compression of the blobs in the summary tree.
+     * @param summary - The summary tree to compress.
+     * @param config - The compression config.
+     * @returns - The compressed summary tree.
+     */
+    static compressSummary(summary: ISummaryTree, config: ICompressionStorageConfig): ISummaryTree;
+    /**
+     * This method read blob from the storage and decompresses it if it is compressed.
+     * @param id - The id of the blob to read.
+     * @returns - The decompressed blob.
+     */
+    readBlob(id: string): Promise<ArrayBufferLike>;
+    /**
+     * This method loads the snapshot tree from the server. It also checks, if the compression markup blob is present
+     * and setups the compression flag accordingly. It also identifies the blobs that are not compressed and do not contain
+     * algorithm byte prefix and store them.
+     * @param version - The version of the snapshot tree to load.
+     * @param scenarioName - The scenario name of the snapshot tree to load.
+     * @returns - The snapshot tree.
+     */
+    getSnapshotTree(version?: IVersion | undefined, scenarioName?: string | undefined): Promise<ISnapshotTree | null>;
+    /**
+     * This method uploads the summary to the storage. It performs compression of the blobs in the summary tree.
+     * @param summary - The summary tree to upload.
+     * @param context - The summary context.
+     * @returns - The ID of the uploaded summary.
+     */
+    uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string>;
+    /**
+     * This method downloads the summary from the storage and then applies decompression on the compressed blobs.
+     * @param id - The ID of the summary to be downloaded
+     * @returns - The summary with decompressed blobs
+     */
+    downloadSummary(id: ISummaryHandle): Promise<ISummaryTree>;
+}
+//# sourceMappingURL=documentStorageServiceSummaryBlobCompressionAdapter.d.ts.map

package/lib/adapters/compression/summaryblob/documentStorageServiceSummaryBlobCompressionAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentStorageServiceSummaryBlobCompressionAdapter.d.ts","sourceRoot":"","sources":["../../../../src/adapters/compression/summaryblob/documentStorageServiceSummaryBlobCompressionAdapter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC9F,OAAO,EACN,aAAa,EAEb,cAAc,EACd,YAAY,EACZ,QAAQ,EAGR,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,yBAAyB,EAA+B,MAAM,KAAK,CAAC;AAE7E,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAG3D;;;;;;;;;;GAUG;AACH,qBAAa,wCAAyC,SAAQ,2BAA2B;IAKvF,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJzB,OAAO,CAAC,qBAAqB,CAAkB;gBAG9C,OAAO,EAAE,uBAAuB,EACf,OAAO,EAAE,yBAAyB;IAKpD,IAAW,OAAO,IAAI,uBAAuB,CAE5C;IAED;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS;IAMxB;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAOpC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAmBnC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,6BAA6B;IAK5C;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAI5B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAoBjC;IAEF;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAgBjC;IAEF;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAwBzB;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAqBzB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAoCjC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAkBxC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAOpC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IASnC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAsBnC;;;;;OAKG;WACW,eAAe,CAC5B,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,yBAAyB,GAC/B,YAAY;IAaf;;;;OAIG;IACmB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAYpE;;;;;;;OAOG;IACmB,eAAe,CACpC,OAAO,CAAC,EAAE,QAAQ,GAAG,SAAS,EAC9B,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,GAE/B,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAShC;;;;;OAKG;IACmB,wBAAwB,CAC7C,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,eAAe,GACtB,OAAO,CAAC,MAAM,CAAC;IAQlB;;;;OAIG;IACmB,eAAe,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;CAYhF"}

package/lib/adapters/compression/summaryblob/documentStorageServiceSummaryBlobCompressionAdapter.js

@@ -0,0 +1,361 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { IsoBuffer, assert } from "@fluidframework/common-utils";
+import { SummaryType, } from "@fluidframework/protocol-definitions";
+import { compress, decompress } from "lz4js";
+import { DocumentStorageServiceProxy } from "../../../documentStorageServiceProxy";
+import { SummaryCompressionAlgorithm } from "../";
+export const blobHeadersBlobName = ".metadata.blobHeaders";
+const metadataBlobName = ".metadata";
+/**
+ * This class is a proxy for the IDocumentStorageService that compresses and decompresses blobs in the summary.
+ * The identification of the compressed blobs is done by adding a compression markup blob to the summary.
+ * Even if the markup blob is present, it does not mean that all blobs are compressed. The blob,
+ * which is compressed also contain the compression algorithm enumerated value from the
+ * SummaryCompressionAlgorithm enumeration in the first byte . If the blob is not
+ * commpressed, it contains the first byte equals to SummaryCompressionAlgorithm.None .
+ * In case, the markup blob is present, it is expected that the first byte of the markup blob
+ * will contain the info about the compression. If the first byte is not present, it is assumed
+ * that the compression is not enabled and no first prefix byte is present in the blobs.
+ */
+export class DocumentStorageServiceCompressionAdapter extends DocumentStorageServiceProxy {
+    constructor(service, _config) {
+        super(service);
+        this._config = _config;
+        this._isCompressionEnabled = false;
+    }
+    get service() {
+        return this.internalStorageService;
+    }
+    /**
+     * This method returns true if there is a compression markup byte in the blob, otherwise false.
+     * @param blob - The blob to compress.
+     * @returns - True if there is a compression markup byte in the blob, otherwise false.
+     */
+    static hasPrefix(blob) {
+        const firstByte = IsoBuffer.from(blob)[0];
+        // eslint-disable-next-line no-bitwise
+        return (firstByte & 0xf0) === 0xb0;
+    }
+    /**
+     * This method reads the first byte from the given blob and maps that byte to the compression algorithm.
+     * @param blob - The maybe compressed blob.
+     */
+    static readAlgorithmFromBlob(blob) {
+        return !this.hasPrefix(blob)
+            ? SummaryCompressionAlgorithm.None
+            : // eslint-disable-next-line no-bitwise
+                IsoBuffer.from(blob)[0] & 0x0f;
+    }
+    /**
+     * This method writes the given algorithm to the blob as the first byte.
+     * @param blob - The blob to write the algorithm to.
+     * @param algorithm - The algorithm to write.
+     * @returns - The blob with the algorithm as the first byte.
+     */
+    static writeAlgorithmToBlob(blob, algorithm) {
+        if (algorithm === SummaryCompressionAlgorithm.None) {
+            const firstByte = IsoBuffer.from(blob)[0];
+            // eslint-disable-next-line no-bitwise
+            if ((firstByte & 0xf0) !== 0xb0) {
+                return blob;
+            }
+        }
+        assert(algorithm < 0x10, 0x6f5 /* Algorithm should be less than 0x10 */);
+        const blobView = new Uint8Array(blob);
+        const blobLength = blobView.length;
+        const newBlob = new Uint8Array(blobLength + 1);
+        // eslint-disable-next-line no-bitwise
+        const prefix = 0xb0 | algorithm;
+        newBlob[0] = prefix;
+        newBlob.set(blobView, 1);
+        return IsoBuffer.from(newBlob);
+    }
+    /**
+     * This method removes the algorithm markup prefix from the blob (1 byte)
+     * @param blob - The blob to remove the prefix from.
+     * @returns - The blob without the prefix.
+     */
+    static removePrefixFromBlobIfPresent(blob) {
+        const blobView = new Uint8Array(blob);
+        return this.hasPrefix(blob) ? IsoBuffer.from(blobView.subarray(1)) : blob;
+    }
+    /**
+     * This method converts the given argument to Uint8Array. If the parameter is already Uint8Array,
+     * it is just returned as is. If the parameter is string, it is converted to Uint8Array using
+     * TextEncoder.
+     * @param input - The input to convert to Uint8Array.
+     * @returns - The Uint8Array representation of the input.
+     */
+    static toBinaryArray(input) {
+        return typeof input === "string" ? new TextEncoder().encode(input) : input;
+    }
+    /**
+     * This method encodes the given blob according to the given config.
+     * @param file - The blob to encode.
+     * @param config - The config to use for encoding.
+     * @returns - The encoded blob.
+     */
+    static encodeBlob(file, config) {
+        let maybeCompressed;
+        let algorithm = config.algorithm;
+        if (new Uint8Array(file).length < config.minSizeToCompress) {
+            maybeCompressed = file;
+            algorithm = SummaryCompressionAlgorithm.None;
+        }
+        else if (algorithm === SummaryCompressionAlgorithm.None) {
+            maybeCompressed = file;
+        }
+        else if (algorithm === SummaryCompressionAlgorithm.LZ4) {
+            const compressed = compress(file);
+            maybeCompressed = compressed;
+        }
+        else {
+            throw new Error(`Unknown Algorithm ${config.algorithm}`);
+        }
+        maybeCompressed = DocumentStorageServiceCompressionAdapter.writeAlgorithmToBlob(maybeCompressed, algorithm);
+        return maybeCompressed;
+    }
+    /**
+     * This method decodes the given blob.
+     * @param file - The blob to decode.
+     * @returns - The decoded blob.
+     */
+    static decodeBlob(file) {
+        let decompressed;
+        let originalBlob;
+        let algorithm;
+        if (this.hasPrefix(file)) {
+            algorithm = DocumentStorageServiceCompressionAdapter.readAlgorithmFromBlob(file);
+            originalBlob = this.removePrefixFromBlobIfPresent(file);
+        }
+        else {
+            algorithm = SummaryCompressionAlgorithm.None;
+            originalBlob = file;
+        }
+        if (algorithm === SummaryCompressionAlgorithm.None) {
+            decompressed = originalBlob;
+        }
+        else if (algorithm === SummaryCompressionAlgorithm.LZ4) {
+            decompressed = decompress(originalBlob);
+        }
+        else {
+            throw new Error(`Unknown Algorithm ${algorithm}`);
+        }
+        return decompressed;
+    }
+    /**
+     * This method traverses the SummaryObject recursively. If it finds the ISummaryBlob object,
+     * it applies encoding/decoding on it according to the given isEncode flag.
+     * @param isEncode - True if the encoding should be applied, false if the decoding should be applied.
+     * @param input - The summary object to traverse.
+     * @param encoder - The encoder function to use.
+     * @param decoder - The decoder function to use.
+     * @param config - The config to use for encoding.
+     * @param context - The summary context.
+     * @returns - The summary object with the encoded/decoded blob.
+     */
+    static recursivelyReplace(isEncode, input, encoder, decoder, config, context) {
+        assert(typeof input === "object", 0x6f6 /* input must be a non-null object */);
+        const maybeReplaced = isEncode ? encoder(input, config) : decoder(input);
+        if (maybeReplaced !== input) {
+            return maybeReplaced;
+        }
+        let clone;
+        for (const key of Object.keys(input)) {
+            const value = input[key];
+            if (Boolean(value) && typeof value === "object") {
+                const replaced = this.recursivelyReplace(isEncode, value, encoder, decoder, config, context);
+                if (replaced !== value) {
+                    clone = clone !== null && clone !== void 0 ? clone : (Array.isArray(input) ? [...input] : Object.assign({}, input));
+                    clone[key] = replaced;
+                }
+            }
+        }
+        return (clone !== null && clone !== void 0 ? clone : input);
+    }
+    /**
+     * This method traverses the SummaryTree recursively. If it finds the ISummaryBlob object with the key '.metadata',
+     * it returns the summary tree containing that blob.
+     *
+     * @param summary - The summary tree to traverse.
+     * @returns - The summary tree containing the metadata blob.
+     */
+    static findMetadataHolderSummary(summary) {
+        assert(typeof summary === "object", 0x6f7 /* summary must be a non-null object */);
+        for (const key of Object.keys(summary.tree)) {
+            const value = summary.tree[key];
+            if (Boolean(value) && value.type === SummaryType.Tree) {
+                const found = this.findMetadataHolderSummary(value);
+                if (found) {
+                    return found;
+                }
+            }
+            if (Boolean(value) && key === metadataBlobName && value.type === SummaryType.Blob) {
+                return summary;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * This method obtains the summary tree containing the metadata blob. It returns the content
+     * of the tree atribute.
+     * @param summary - The summary tree to traverse.
+     * @returns - The content of the tree attribute of the summary tree containing the metadata blob.
+     */
+    static getMetadataHolderTree(summary) {
+        const metadataHolder = this.findMetadataHolderSummary(summary);
+        assert(metadataHolder !== undefined, 0x6f8 /* metadataHolder must be a non-null object */);
+        const metadataHolderTree = metadataHolder.tree;
+        return metadataHolderTree;
+    }
+    /**
+     * This method adds the compression markup blob to the nested summary tree containing the metadata blob.
+     * @param summary - The top summary tree to put the compression markup blob into.
+     */
+    static putCompressionMarkup(summary) {
+        const metadataHolderTree = DocumentStorageServiceCompressionAdapter.getMetadataHolderTree(summary);
+        metadataHolderTree[blobHeadersBlobName] = {
+            type: 2,
+            content: "",
+        };
+    }
+    /**
+     * This method traverses the SnapshotTree recursively. If it finds the ISummaryBlob object with the key '.metadata',
+     * it checks, if the SummaryTree holder of that object also contains the compression markup blob. If it is found,
+     * it returns true, otherwise false.
+     * @param snapshot - The snapshot tree to traverse.
+     * @returns - True if the compression markup blob is found, otherwise false.
+     */
+    static hasCompressionMarkup(snapshot) {
+        assert(typeof snapshot === "object", 0x6f9 /* snapshot must be a non-null object */);
+        for (const key of Object.keys(snapshot.blobs)) {
+            if (key === metadataBlobName) {
+                const value = snapshot.blobs[blobHeadersBlobName];
+                if (value !== undefined) {
+                    return true;
+                }
+            }
+        }
+        for (const key of Object.keys(snapshot.trees)) {
+            const value = snapshot[key];
+            if (value !== undefined) {
+                const found = this.hasCompressionMarkup(value);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * This method performs compression of the blobs in the summary tree.
+     * @param summary - The summary tree to compress.
+     * @param config - The compression config.
+     * @returns - The compressed summary tree.
+     */
+    static compressSummary(summary, config) {
+        this.putCompressionMarkup(summary);
+        const prep = DocumentStorageServiceCompressionAdapter.recursivelyReplace(true, summary, DocumentStorageServiceCompressionAdapter.blobEncoder, DocumentStorageServiceCompressionAdapter.blobDecoder, config);
+        //	console.log(`Miso summary-blob Summary Upload: ${JSON.stringify(prep).length}`);
+        return prep;
+    }
+    /**
+     * This method read blob from the storage and decompresses it if it is compressed.
+     * @param id - The id of the blob to read.
+     * @returns - The decompressed blob.
+     */
+    async readBlob(id) {
+        const originalBlob = await super.readBlob(id);
+        if (!this._isCompressionEnabled) {
+            return originalBlob;
+        }
+        else {
+            const decompressedBlob = DocumentStorageServiceCompressionAdapter.decodeBlob(originalBlob);
+            //			console.log(`Miso summary-blob Blob read END : ${id} ${decompressedBlob.byteLength}`);
+            return decompressedBlob;
+        }
+    }
+    /**
+     * This method loads the snapshot tree from the server. It also checks, if the compression markup blob is present
+     * and setups the compression flag accordingly. It also identifies the blobs that are not compressed and do not contain
+     * algorithm byte prefix and store them.
+     * @param version - The version of the snapshot tree to load.
+     * @param scenarioName - The scenario name of the snapshot tree to load.
+     * @returns - The snapshot tree.
+     */
+    async getSnapshotTree(version, scenarioName) {
+        const snapshotTree = await super.getSnapshotTree(version, scenarioName);
+        this._isCompressionEnabled =
+            snapshotTree !== undefined &&
+                snapshotTree !== null &&
+                DocumentStorageServiceCompressionAdapter.hasCompressionMarkup(snapshotTree);
+        return snapshotTree;
+    }
+    /**
+     * This method uploads the summary to the storage. It performs compression of the blobs in the summary tree.
+     * @param summary - The summary tree to upload.
+     * @param context - The summary context.
+     * @returns - The ID of the uploaded summary.
+     */
+    async uploadSummaryWithContext(summary, context) {
+        const prep = DocumentStorageServiceCompressionAdapter.compressSummary(summary, this._config);
+        return super.uploadSummaryWithContext(prep, context);
+    }
+    /**
+     * This method downloads the summary from the storage and then applies decompression on the compressed blobs.
+     * @param id - The ID of the summary to be downloaded
+     * @returns - The summary with decompressed blobs
+     */
+    async downloadSummary(id) {
+        const summary = await super.downloadSummary(id);
+        return !this._isCompressionEnabled
+            ? summary
+            : DocumentStorageServiceCompressionAdapter.recursivelyReplace(false, summary, DocumentStorageServiceCompressionAdapter.blobEncoder, DocumentStorageServiceCompressionAdapter.blobDecoder, this._config);
+    }
+}
+/**
+ * This method encodes the blob inside the given summary object of the SummaryType.Blob type using the given config
+ * containing  the compression algorithm.
+ * @param input - The summary object to encode.
+ * @param config - The config containing the compression algorithm.
+ * @returns - The summary object with the encoded blob.
+ */
+DocumentStorageServiceCompressionAdapter.blobEncoder = (input, config) => {
+    if (input.type === SummaryType.Blob) {
+        const summaryBlob = input;
+        const original = DocumentStorageServiceCompressionAdapter.toBinaryArray(summaryBlob.content);
+        const processed = DocumentStorageServiceCompressionAdapter.encodeBlob(original, config);
+        const newSummaryBlob = {
+            type: SummaryType.Blob,
+            content: IsoBuffer.from(processed),
+        };
+        return newSummaryBlob;
+    }
+    else {
+        return input;
+    }
+};
+/**
+ * This method decodes the blob inside the given summary object of the SummaryType.Blob type.
+ * @param input - The summary object to decode.
+ * @returns - The summary object with the decoded blob.
+ */
+DocumentStorageServiceCompressionAdapter.blobDecoder = (input) => {
+    if (input.type === SummaryType.Blob) {
+        const summaryBlob = input;
+        const original = DocumentStorageServiceCompressionAdapter.toBinaryArray(summaryBlob.content);
+        const processed = DocumentStorageServiceCompressionAdapter.decodeBlob(original);
+        const newSummaryBlob = {
+            type: SummaryType.Blob,
+            content: IsoBuffer.from(processed),
+        };
+        return newSummaryBlob;
+    }
+    else {
+        return input;
+    }
+};
+//# sourceMappingURL=documentStorageServiceSummaryBlobCompressionAdapter.js.map