@fluidframework/odsp-driver 2.0.0-internal.1.0.0.83139 → 2.0.0-internal.1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/odsp-driver",
-  "version": "2.0.0-internal.1.0.0.83139",
+  "version": "2.0.0-internal.1.1.1",
   "description": "Socket storage implementation for SPO and ODC",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -61,17 +61,17 @@
   },
   "dependencies": {
     "@fluidframework/common-definitions": "^0.20.1",
-    "@fluidframework/common-utils": "^0.32.1",
-    "@fluidframework/core-interfaces": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/driver-base": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/driver-definitions": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/driver-utils": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/gitresources": "^0.1037.1000-0",
-    "@fluidframework/odsp-doclib-utils": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/odsp-driver-definitions": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/protocol-base": "^0.1037.1000-0",
-    "@fluidframework/protocol-definitions": "^0.1029.1000-0",
-    "@fluidframework/telemetry-utils": "2.0.0-internal.1.0.0.83139",
+    "@fluidframework/common-utils": "^1.0.0",
+    "@fluidframework/core-interfaces": "^2.0.0-internal.1.1.1",
+    "@fluidframework/driver-base": "^2.0.0-internal.1.1.1",
+    "@fluidframework/driver-definitions": "^2.0.0-internal.1.1.1",
+    "@fluidframework/driver-utils": "^2.0.0-internal.1.1.1",
+    "@fluidframework/gitresources": "^0.1037.1000",
+    "@fluidframework/odsp-doclib-utils": "^2.0.0-internal.1.1.1",
+    "@fluidframework/odsp-driver-definitions": "^2.0.0-internal.1.1.1",
+    "@fluidframework/protocol-base": "^0.1037.1000",
+    "@fluidframework/protocol-definitions": "^1.0.0",
+    "@fluidframework/telemetry-utils": "^2.0.0-internal.1.1.1",
     "abort-controller": "^3.0.0",
     "node-fetch": "^2.6.1",
     "socket.io-client": "^4.4.1",
@@ -79,9 +79,9 @@
   },
   "devDependencies": {
     "@fluidframework/build-common": "^0.24.0",
-    "@fluidframework/build-tools": "^0.3.0-0",
+    "@fluidframework/build-tools": "^0.3.1000",
     "@fluidframework/eslint-config-fluid": "^0.28.2000",
-    "@fluidframework/mocha-test-setup": "2.0.0-internal.1.0.0.83139",
+    "@fluidframework/mocha-test-setup": "^2.0.0-internal.1.1.1",
     "@fluidframework/odsp-driver-previous": "npm:@fluidframework/odsp-driver@^1.0.0",
     "@microsoft/api-extractor": "^7.22.2",
     "@rushstack/eslint-config": "^2.5.1",
@@ -89,7 +89,7 @@
     "@types/node-fetch": "^2.5.10",
     "@types/sha.js": "^2.4.0",
     "concurrently": "^6.2.0",
-    "copyfiles": "^2.1.0",
+    "copyfiles": "^2.4.1",
     "cross-env": "^7.0.2",
     "eslint": "~8.6.0",
     "mocha": "^10.0.0",

package/src/contracts.ts

@@ -216,6 +216,8 @@ export interface ICreateFileResponse {
     itemId: string;
     itemUrl: string;
     sequenceNumber: number;
+    // sharing object contains shareId, sharingLink data or error in the response
+    sharing?: any;
     sharingLink?: string;
     sharingLinkErrorReason?: string;
 }

package/src/createFile.ts

@@ -15,6 +15,9 @@ import {
     InstrumentedStorageTokenFetcher,
     IOdspResolvedUrl,
     OdspErrorType,
+    ShareLinkInfoType,
+    ISharingLinkKind,
+    ShareLinkTypes,
 } from "@fluidframework/odsp-driver-definitions";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
 import {
@@ -26,6 +29,7 @@ import {
 } from "./contracts";
 import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth";
 import {
+    buildOdspShareLinkReqParams,
     createCacheSnapshotKey,
     getWithRetryForTokenRefresh,
     INewFileInfo,
@@ -61,6 +65,8 @@ export async function createNewFluidFile(
     createNewCaching: boolean,
     forceAccessTokenViaAuthorizationHeader: boolean,
     isClpCompliantApp?: boolean,
+    enableSingleRequestForShareLinkWithCreate?: boolean,
+    enableShareLinkWithCreate?: boolean,
 ): Promise<IOdspResolvedUrl> {
     // Check for valid filename before the request to create file is actually made.
     if (isInvalidFileName(newFileInfo.filename)) {
@@ -71,8 +77,7 @@ export async function createNewFluidFile(
 
     let itemId: string;
     let summaryHandle: string = "";
-    let sharingLink: string | undefined;
-    let sharingLinkErrorReason: string | undefined;
+    let shareLinkInfo: ShareLinkInfoType | undefined;
     if (createNewSummary === undefined) {
         itemId = await createNewEmptyFluidFile(
             getStorageToken, newFileInfo, logger, epochTracker, forceAccessTokenViaAuthorizationHeader);
@@ -87,8 +92,12 @@ export async function createNewFluidFile(
         );
         itemId = content.itemId;
         summaryHandle = content.id;
-        sharingLink = content.sharingLink;
-        sharingLinkErrorReason = content.sharingLinkErrorReason;
+
+        shareLinkInfo = extractShareLinkData(
+            newFileInfo.createLinkType,
+            content,
+            enableSingleRequestForShareLinkWithCreate,
+            enableShareLinkWithCreate);
     }
 
     const odspUrl = createOdspUrl({ ...newFileInfo, itemId, dataStorePath: "/" });
@@ -100,15 +109,7 @@ export async function createNewFluidFile(
     fileEntry.docId = odspResolvedUrl.hashedDocumentId;
     fileEntry.resolvedUrl = odspResolvedUrl;
 
-    if (sharingLink || sharingLinkErrorReason) {
-        odspResolvedUrl.shareLinkInfo = {
-            createLink: {
-                type: newFileInfo.createLinkType,
-                link: sharingLink,
-                error: sharingLinkErrorReason,
-            },
-        };
-    }
+    odspResolvedUrl.shareLinkInfo = shareLinkInfo;
 
     if (createNewSummary !== undefined && createNewCaching) {
         assert(summaryHandle !== undefined, 0x203 /* "Summary handle is undefined" */);
@@ -120,6 +121,61 @@ export async function createNewFluidFile(
     return odspResolvedUrl;
 }
 
+/**
+ * If user requested creation of a sharing link along with the creation of the file by providing either
+ * createLinkType (now deprecated) or createLinkScope in the request parameters, extract and save
+ * sharing link information from the response if it is available.
+ * In case there was an error in creation of the sharing link, error is provided back in the response,
+ * and does not impact the creation of file in ODSP.
+ * @param requestedSharingLinkKind - Kind of sharing link requested to be created along with the creation of file.
+ * @param response - Response object received from the /snapshot api call
+ * @returns Sharing link information received in the response from a successful creation of a file.
+ */
+function extractShareLinkData(
+    requestedSharingLinkKind: ShareLinkTypes | ISharingLinkKind | undefined,
+    response: ICreateFileResponse,
+    enableSingleRequestForShareLinkWithCreate?: boolean,
+    enableShareLinkWithCreate?: boolean,
+): ShareLinkInfoType | undefined {
+    if (!requestedSharingLinkKind) {
+        return;
+    }
+    let shareLinkInfo: ShareLinkInfoType | undefined;
+    if (enableSingleRequestForShareLinkWithCreate) {
+        const { sharing } = response;
+        if (!sharing) {
+            return;
+        }
+        shareLinkInfo = {
+            createLink: {
+                type: requestedSharingLinkKind,
+                link: sharing.sharingLink ? {
+                    scope: sharing.sharingLink.scope,
+                    role: sharing.sharingLink.type,
+                    webUrl: sharing.sharingLink.webUrl,
+                    ...sharing.sharingLink,
+                } : undefined,
+                error: sharing.error,
+                shareId: sharing.shareId,
+            },
+        };
+    } else if (enableShareLinkWithCreate) {
+        const { sharing, sharingLink, sharingLinkErrorReason } = response;
+        if (!sharingLink && !sharingLinkErrorReason) {
+            return;
+        }
+        shareLinkInfo = {
+            createLink: {
+                type: requestedSharingLinkKind,
+                link: sharingLink,
+                error: sharingLinkErrorReason,
+                shareId: sharing?.shareId,
+            },
+        };
+    }
+    return shareLinkInfo;
+}
+
 export async function createNewEmptyFluidFile(
     getStorageToken: InstrumentedStorageTokenFetcher,
     newFileInfo: INewFileInfo,
@@ -192,8 +248,12 @@ export async function createNewFluidFileFromSummary(
         `${filePath}/${encodedFilename}`;
 
     const containerSnapshot = convertSummaryIntoContainerSnapshot(createNewSummary);
-    const initialUrl = `${baseUrl}:/opStream/snapshots/snapshot${newFileInfo.createLinkType ?
-        `?createLinkType=${newFileInfo.createLinkType}` : ""}`;
+
+    // Build share link parameter based on the createLinkType provided so that the
+    // snapshot api can create and return the share link along with creation of file in the response.
+    const createShareLinkParam = buildOdspShareLinkReqParams(newFileInfo.createLinkType);
+    const initialUrl =
+        `${baseUrl}:/opStream/snapshots/snapshot${createShareLinkParam ? `?${createShareLinkParam}` : ""}`;
 
     return getWithRetryForTokenRefresh(async (options) => {
         const storageToken = await getStorageToken(options, "CreateNewFile");

package/src/createOdspCreateContainerRequest.ts

@@ -4,7 +4,8 @@
  */
 import { IRequest } from "@fluidframework/core-interfaces";
 import { DriverHeader } from "@fluidframework/driver-definitions";
-import { ShareLinkTypes } from "@fluidframework/odsp-driver-definitions";
+import { ShareLinkTypes, ISharingLinkKind } from "@fluidframework/odsp-driver-definitions";
+import { buildOdspShareLinkReqParams } from "./odspUtils";
 
 /**
  * Create the request object with url and headers for creating a new file on OneDrive Sharepoint
@@ -12,19 +13,21 @@ import { ShareLinkTypes } from "@fluidframework/odsp-driver-definitions";
  * @param driveId - drive identifier
  * @param filePath - path where file needs to be created
  * @param fileName - name of the new file to be created
- * @param createLinkType - type of sharing link you would like to create for this file
+ * @param createShareLinkType - type of sharing link you would like to create for this file. ShareLinkTypes
+ * will be deprecated soon, so for any new implementation please provide createShareLinkType of type ShareLink
  */
 export function createOdspCreateContainerRequest(
     siteUrl: string,
     driveId: string,
     filePath: string,
     fileName: string,
-    createLinkType?: ShareLinkTypes,
+    createShareLinkType?: ShareLinkTypes | ISharingLinkKind,
 ): IRequest {
+    const shareLinkRequestParams = buildOdspShareLinkReqParams(createShareLinkType);
     const createNewRequest: IRequest = {
         url: `${siteUrl}?driveId=${encodeURIComponent(
             driveId,
-        )}&path=${encodeURIComponent(filePath)}${createLinkType ? `&createLinkType=${createLinkType}` : ""}`,
+        )}&path=${encodeURIComponent(filePath)}${shareLinkRequestParams ? `&${shareLinkRequestParams}` : ""}`,
         headers: {
             [DriverHeader.createNew]: {
                 fileName,

package/src/fetchSnapshot.ts

@@ -49,7 +49,6 @@ export enum SnapshotFormatSupportType {
  * @param token - token used for authorization in the request
  * @param storageFetchWrapper - Implementation of the get/post methods used to fetch the snapshot
  * @param versionId - id of specific snapshot to be fetched
- * @param fetchFullSnapshot - whether we want to fetch full snapshot(with blobs)
  * @param forceAccessTokenViaAuthorizationHeader - whether to force passing given token via authorization header
  * @returns A promise of the snapshot and the status code of the response
  */
@@ -57,22 +56,14 @@ export async function fetchSnapshot(
     snapshotUrl: string,
     token: string | null,
     versionId: string,
-    fetchFullSnapshot: boolean,
     forceAccessTokenViaAuthorizationHeader: boolean,
     logger: ITelemetryLogger,
     snapshotDownloader: (url: string, fetchOptions: { [index: string]: any; }) => Promise<IOdspResponse<unknown>>,
 ): Promise<ISnapshotContents> {
     const path = `/trees/${versionId}`;
-    let queryParams: ISnapshotOptions = {};
-
-    if (fetchFullSnapshot) {
-        if (versionId !== "latest") {
-            queryParams = { channels: 1, blobs: 2 };
-        } else {
-            queryParams = { deltas: 1, channels: 1, blobs: 2 };
-        }
-    }
-
+    // We just want to fetch tree here. So explicitly set to not fetch blobs and deltas
+    // as by default server will send that.
+    const queryParams: ISnapshotOptions = { deltas: 0, blobs: 0 };
     const queryString = getQueryString(queryParams);
     const { url, headers } = getUrlAndHeadersWithAuth(
         `${snapshotUrl}${path}${queryString}`, token, forceAccessTokenViaAuthorizationHeader);
@@ -252,9 +243,15 @@ async function fetchLatestSnapshotCore(
                 });
 
                 let parsedSnapshotContents: IOdspResponse<ISnapshotContents> | undefined;
+                let contentTypeToRead: string | undefined;
+                if (contentType?.indexOf("application/ms-fluid") !== -1) {
+                    contentTypeToRead = "application/ms-fluid";
+                } else if (contentType?.indexOf("application/json") !== -1) {
+                    contentTypeToRead = "application/json";
+                }
 
                 try {
-                    switch (contentType) {
+                    switch (contentTypeToRead) {
                         case "application/json": {
                             const text = await odspResponse.content.text();
                             propsToLog.bodySize = text.length;
@@ -549,14 +546,12 @@ export async function downloadSnapshot(
     };
     // Decide what snapshot format to fetch as per the feature gate.
     switch (snapshotFormatFetchType) {
-        case SnapshotFormatSupportType.JsonAndBinary:
-            headers.accept = `application/json, application/ms-fluid; v=${currentReadVersion}`;
-            break;
         case SnapshotFormatSupportType.Binary:
             headers.accept = `application/ms-fluid; v=${currentReadVersion}`;
             break;
         default:
-            headers.accept = "application/json";
+            // By default ask both versions and let the server decide the format.
+            headers.accept = `application/json, application/ms-fluid; v=${currentReadVersion}`;
     }
 
     const odspResponse = await (epochTracker?.fetch(url, fetchOptions, "treesLatest", true, scenarioName) ??

package/src/odspDeltaStorageService.ts

@@ -31,7 +31,7 @@ export class OdspDeltaStorageService {
     }
 
     /**
-     * Retrieves ops from cache
+     * Retrieves ops from storage
      * @param from - inclusive
      * @param to - exclusive
      * @param telemetryProps - properties to add when issuing telemetry events

package/src/odspDocumentService.ts

@@ -176,7 +176,6 @@ export class OdspDocumentService implements IDocumentService {
                 this.odspResolvedUrl,
                 this.getStorageToken,
                 this.mc.logger,
-                true,
                 this.cache,
                 this.hostPolicy,
                 this.epochTracker,
@@ -189,7 +188,7 @@ export class OdspDocumentService implements IDocumentService {
                 },
                 () => {
                     assert(this.relayServiceTenantAndSessionId !== undefined,
-                        "relayServiceTenantAndSessionId should be present");
+                        0x37b /* relayServiceTenantAndSessionId should be present */);
                     return this.relayServiceTenantAndSessionId;
                 },
                 this.mc.config.getNumber("Fluid.Driver.Odsp.snapshotFormatFetchType"),

package/src/odspDocumentServiceFactoryCore.ts

@@ -26,6 +26,10 @@ import {
     HostStoragePolicy,
     IFileEntry,
     IOdspUrlParts,
+    SharingLinkScope,
+    SharingLinkRole,
+    ShareLinkTypes,
+    ISharingLinkKind,
 } from "@fluidframework/odsp-driver-definitions";
 import type { io as SocketIOClientStatic } from "socket.io-client";
 import { v4 as uuid } from "uuid";
@@ -84,15 +88,13 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
             }
         }
 
+        const createShareLinkParam = getSharingLinkParams(this.hostPolicy, searchParams);
         const newFileInfo: INewFileInfo = {
             driveId: odspResolvedUrl.driveId,
             siteUrl: odspResolvedUrl.siteUrl,
             filePath,
             filename: odspResolvedUrl.fileName,
-            // set createLinkType to undefined if enableShareLinkWithCreate is set to false,
-            // so that share link creation with create file can be enabled
-            createLinkType: this.hostPolicy.enableShareLinkWithCreate ?
-            odspResolvedUrl.shareLinkInfo?.createLink?.type : undefined,
+            createLinkType: createShareLinkParam,
         };
 
         const odspLogger = createOdspLogger(logger);
@@ -110,6 +112,10 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
             {
                 eventName: "CreateNew",
                 isWithSummaryUpload: true,
+                createShareLinkParam: JSON.stringify(createShareLinkParam),
+                enableShareLinkWithCreate: this.hostPolicy.enableShareLinkWithCreate,
+                enableSingleRequestForShareLinkWithCreate:
+                    this.hostPolicy.enableSingleRequestForShareLinkWithCreate,
             },
             async (event) => {
                 odspResolvedUrl = await createNewFluidFile(
@@ -127,6 +133,8 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
                     this.hostPolicy.cacheCreateNewSummary ?? true,
                     !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
                     odspResolvedUrl.isClpCompliantApp,
+                    this.hostPolicy.enableSingleRequestForShareLinkWithCreate,
+                    this.hostPolicy.enableShareLinkWithCreate,
                 );
                 const docService = this.createDocumentServiceCore(odspResolvedUrl, odspLogger,
                     cacheAndTracker, clientIsSummarizer);
@@ -223,3 +231,31 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
         );
     }
 }
+
+/**
+ * Extract the sharing link kind from the resolved URL's query paramerters
+ */
+function getSharingLinkParams(
+    hostPolicy: HostStoragePolicy,
+    searchParams: URLSearchParams,
+): ShareLinkTypes | ISharingLinkKind | undefined {
+    // extract request parameters for creation of sharing link (if provided) if the feature is enabled
+    let createShareLinkParam: ShareLinkTypes | ISharingLinkKind | undefined;
+    if (hostPolicy.enableSingleRequestForShareLinkWithCreate) {
+        const createLinkScope = searchParams.get("createLinkScope");
+        const createLinkRole = searchParams.get("createLinkRole");
+        if (createLinkScope && SharingLinkScope[createLinkScope]) {
+            createShareLinkParam = {
+                scope: SharingLinkScope[createLinkScope],
+                ...(createLinkRole && SharingLinkRole[createLinkRole] ?
+                    { role: SharingLinkRole[createLinkRole] } : {}),
+            };
+        }
+    } else if (hostPolicy.enableShareLinkWithCreate) {
+        const createLinkType = searchParams.get("createLinkType");
+        if (createLinkType && ShareLinkTypes[createLinkType]) {
+            createShareLinkParam = ShareLinkTypes[createLinkType || ""];
+        }
+    }
+    return createShareLinkParam;
+}

package/src/odspDocumentStorageManager.ts

@@ -88,7 +88,6 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
         private readonly odspResolvedUrl: IOdspResolvedUrl,
         private readonly getStorageToken: InstrumentedStorageTokenFetcher,
         private readonly logger: ITelemetryLogger,
-        private readonly fetchFullSnapshot: boolean,
         private readonly cache: IOdspCache,
         private readonly hostPolicy: HostStoragePolicyInternal,
         private readonly epochTracker: EpochTracker,
@@ -228,8 +227,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
         }
 
         // If count is one, we can use the trees/latest API, which returns the latest version and trees in a single request for better performance
-        // Do it only once - we might get more here due to summarizer - it needs only container tree, not full snapshot.
-        if (this.firstVersionCall && count === 1 && (blobid === null || blobid === this.documentId)) {
+        if (count === 1 && (blobid === null || blobid === this.documentId)) {
             const hostSnapshotOptions = this.hostPolicy.snapshotOptions;
             const odspSnapshotCacheValue: ISnapshotContents = await PerformanceEvent.timedExecAsync(
                 this.logger,
@@ -275,7 +273,10 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                         // Based on the concurrentSnapshotFetch policy:
                         // Either retrieve both the network and cache snapshots concurrently and pick the first to return,
                         // or grab the cache value and then the network value if the cache value returns undefined.
-                        if (this.hostPolicy.concurrentSnapshotFetch && !this.hostPolicy.summarizerClient) {
+                        // For summarizer which could call this during refreshing of summary parent, always use the cache
+                        // first. Also for other clients, if it is not critical path which is determined by firstVersionCall,
+                        // then also check the cache first.
+                        if (this.firstVersionCall && this.hostPolicy.concurrentSnapshotFetch && !this.hostPolicy.summarizerClient) {
                             const networkSnapshotP = this.fetchSnapshot(hostSnapshotOptions, scenarioName);
 
                             // Ensure that failures on both paths are ignored initially.
@@ -306,11 +307,18 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                             // while the first caller is awaiting later async code in this block.
 
                             retrievedSnapshot = await cachedSnapshotP;
-
-                            method = retrievedSnapshot !== undefined ? "cache" : "network";
-
-                            if (retrievedSnapshot === undefined) {
-                                retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions, scenarioName);
+                            if (retrievedSnapshot !== undefined) {
+                                method = "cache";
+                            } else {
+                                method = "network";
+                                const options: ISnapshotOptions = { ...hostSnapshotOptions };
+                                // Don't fetch the blobs/deltas if it is not the first call. By default server will add
+                                // blobs and deltas to the response.
+                                if (!this.firstVersionCall) {
+                                    options.blobs = 0;
+                                    options.deltas = 0;
+                                }
+                                retrievedSnapshot = await this.fetchSnapshot(options, scenarioName);
                             }
                         }
                     }
@@ -322,10 +330,9 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                 },
             );
 
-            // Successful call, make network calls only
+            // Don't override ops which were fetched during initial load, since we could still need them.
+            const id = this.initializeFromSnapshot(odspSnapshotCacheValue, this.firstVersionCall);
             this.firstVersionCall = false;
-            const id = this.initializeFromSnapshot(odspSnapshotCacheValue);
-
             return id ? [{ id, treeId: undefined! }] : [];
         }
 
@@ -545,7 +552,6 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                 this.snapshotUrl!,
                 storageToken,
                 id,
-                this.fetchFullSnapshot,
                 !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
                 this.logger,
                 snapshotDownloader,

package/src/odspDocumentStorageServiceBase.ts

@@ -244,7 +244,7 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
         return summarySnapshotTree;
     }
 
-    protected initializeFromSnapshot(odspSnapshotCacheValue: ISnapshotContents): string | undefined {
+    protected initializeFromSnapshot(odspSnapshotCacheValue: ISnapshotContents, cacheOps: boolean = true): string | undefined {
         this._snapshotSequenceNumber = odspSnapshotCacheValue.sequenceNumber;
         const { snapshotTree, blobs, ops } = odspSnapshotCacheValue;
 
@@ -260,7 +260,9 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
             this.initBlobsCache(blobs);
         }
 
-        this.ops = ops;
+        if (cacheOps) {
+            this.ops = ops;
+        }
         return id;
     }
 }

package/src/odspUtils.ts

@@ -27,6 +27,7 @@ import {
     isTokenFromCache,
     OdspResourceTokenFetchOptions,
     ShareLinkTypes,
+    ISharingLinkKind,
     TokenFetcher,
     ICacheEntry,
     snapshotKey,
@@ -233,8 +234,10 @@ export interface INewFileInfo {
      * application can request creation of a share link along with the creation of a new file
      * by passing in an optional param to specify the kind of sharing link
      * (at the time of adding this comment Sept/2021), odsp only supports csl
+     * ShareLinkTypes will deprecated in future. Use ISharingLinkKind instead which specifies both
+     * share link type and the role type.
      */
-    createLinkType?: ShareLinkTypes;
+    createLinkType?: ShareLinkTypes | ISharingLinkKind;
 }
 
 export function getOdspResolvedUrl(resolvedUrl: IResolvedUrl): IOdspResolvedUrl {
@@ -348,3 +351,23 @@ export function createCacheSnapshotKey(odspResolvedUrl: IOdspResolvedUrl): ICach
 // 80KB is the max body size that we can put in ump post body for server to be able to accept it.
 // Keeping it 78KB to be a little cautious. As per the telemetry 99p is less than 78KB.
 export const maxUmpPostBodySize = 79872;
+
+/**
+ * Build request parameters to request for the creation of a sharing link along with the creation of the file
+ * through the /snapshot api call.
+ * @param shareLinkType - Kind of sharing link requested
+ * @returns A string of request parameters that can be concatenated with the base URI
+ */
+export function buildOdspShareLinkReqParams(shareLinkType: ShareLinkTypes | ISharingLinkKind | undefined) {
+    if (!shareLinkType) {
+        return;
+    }
+    const scope = (shareLinkType as ISharingLinkKind).scope;
+    if (!scope) {
+        return `createLinkType=${shareLinkType}`;
+    }
+    let shareLinkRequestParams = `createLinkScope=${scope}`;
+    const role = (shareLinkType as ISharingLinkKind).role;
+    shareLinkRequestParams = role ? `${shareLinkRequestParams}&createLinkRole=${role}` : shareLinkRequestParams;
+    return shareLinkRequestParams;
+}

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "2.0.0-internal.1.0.0.83139";
+export const pkgVersion = "2.0.0-internal.1.1.1";