@fluidframework/local-driver 2.0.0-dev.1.4.5.105745 → 2.0.0-dev.2.2.0.111723

package/src/localDocumentStorageService.ts

@@ -0,0 +1,107 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { stringToBuffer, Uint8ArrayToString } from "@fluidframework/common-utils";
+import {
+	IDocumentStorageService,
+	IDocumentStorageServicePolicies,
+	ISummaryContext,
+} from "@fluidframework/driver-definitions";
+import {
+	ICreateBlobResponse,
+	ISnapshotTreeEx,
+	ISummaryHandle,
+	ISummaryTree,
+	IVersion,
+} from "@fluidframework/protocol-definitions";
+import { buildHierarchy } from "@fluidframework/protocol-base";
+import { GitManager, ISummaryUploadManager, SummaryTreeUploadManager } from "@fluidframework/server-services-client";
+
+export class LocalDocumentStorageService implements IDocumentStorageService {
+	// The values of this cache is useless. We only need the keys. So we are always putting
+	// empty strings as values.
+	protected readonly blobsShaCache = new Map<string, string>();
+	private readonly summaryTreeUploadManager: ISummaryUploadManager;
+
+	public get repositoryUrl(): string {
+		return "";
+	}
+
+	constructor(
+		private readonly id: string,
+		private readonly manager: GitManager,
+		public readonly policies: IDocumentStorageServicePolicies = {},
+	) {
+		this.summaryTreeUploadManager = new SummaryTreeUploadManager(
+			manager,
+			this.blobsShaCache,
+			this.getPreviousFullSnapshot.bind(this),
+		);
+	}
+
+	public async getVersions(versionId: string | null, count: number): Promise<IVersion[]> {
+		const id = versionId ? versionId : this.id;
+		const commits = await this.manager.getCommits(id, count);
+		return commits.map((commit) => ({
+			date: commit.commit.author.date,
+			id: commit.sha,
+			treeId: commit.commit.tree.sha,
+		}));
+	}
+
+	public async getSnapshotTree(version?: IVersion): Promise<ISnapshotTreeEx | null> {
+		let requestVersion = version;
+		if (!requestVersion) {
+			const versions = await this.getVersions(this.id, 1);
+			if (versions.length === 0) {
+				return null;
+			}
+
+			requestVersion = versions[0];
+		}
+
+		const rawTree = await this.manager.getTree(requestVersion.treeId);
+		const tree = buildHierarchy(rawTree, this.blobsShaCache, true);
+		return tree;
+	}
+
+	public async readBlob(blobId: string): Promise<ArrayBufferLike> {
+		const blob = await this.manager.getBlob(blobId);
+		this.blobsShaCache.set(blob.sha, "");
+		const bufferContent = stringToBuffer(blob.content, blob.encoding);
+		return bufferContent;
+	}
+
+	public async uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string> {
+		return this.summaryTreeUploadManager.writeSummaryTree(
+			summary,
+			context.ackHandle ?? "",
+			"channel",
+		);
+	}
+
+	public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
+		const uint8ArrayFile = new Uint8Array(file);
+		return this.manager.createBlob(
+			Uint8ArrayToString(
+				uint8ArrayFile, "base64"),
+			"base64").then((r) => ({ id: r.sha, url: r.url }));
+	}
+
+	public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
+		throw new Error("NOT IMPLEMENTED!");
+	}
+
+	private async getPreviousFullSnapshot(parentHandle: string): Promise<ISnapshotTreeEx | null | undefined> {
+		return parentHandle
+			? this.getVersions(parentHandle, 1)
+				.then(async (versions) => {
+					// Clear the cache as the getSnapshotTree call will fill the cache.
+					this.blobsShaCache.clear();
+					return this.getSnapshotTree(versions[0]);
+				})
+			: undefined;
+	}
+}

package/src/localSessionStorageDb.ts

@@ -12,10 +12,10 @@ import { v4 as uuid } from "uuid";
  * Functions include database operations such as queries, insertion and update.
  */
 class LocalSessionStorageCollection<T> implements ICollection<T> {
-    private readonly collectionName: string;
-    constructor(namespace, name) {
-        this.collectionName = `${namespace}-${name}`;
-    }
+    /**
+     * @param collectionName - data type of the collection, e.g. blobs, deltas, trees, etc.
+     */
+    constructor(private readonly collectionName: string) { }
 
     public aggregate(pipeline: any, options?: any): any {
         throw new Error("Method Not Implemented");
@@ -88,7 +88,8 @@ class LocalSessionStorageCollection<T> implements ICollection<T> {
      * {@inheritDoc @fluidframework/server-services-core#ICollection.findAll}
      */
     public async findAll(): Promise<any[]> {
-        return Promise.resolve(this.getAllInternal());
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return this.getAllInternal();
     }
 
     /**
@@ -98,7 +99,8 @@ class LocalSessionStorageCollection<T> implements ICollection<T> {
      * Query is expected to have a member "_id" which is a string used to find value in the database.
      */
     public async findOne(query: any): Promise<any> {
-        return Promise.resolve(this.findOneInternal(query));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return this.findOneInternal(query);
     }
 
     /**
@@ -282,15 +284,10 @@ class LocalSessionStorageCollection<T> implements ICollection<T> {
  */
 class LocalSessionStorageDb extends EventEmitter implements IDb {
     private readonly collections = new Map<string, LocalSessionStorageCollection<any>>();
-    constructor(private readonly namespace) {
-        super();
-    }
-    public async close(): Promise<void> {
-        return Promise.resolve();
-    }
+    public async close(): Promise<void> { }
     public collection<T>(name: string): ICollection<T> {
         if (!this.collections.has(name)) {
-            this.collections.set(name, new LocalSessionStorageCollection<T>(`${this.namespace}-db`, name));
+            this.collections.set(name, new LocalSessionStorageCollection<T>(name));
         }
         return this.collections.get(name) as LocalSessionStorageCollection<T>;
     }
@@ -308,10 +305,7 @@ class LocalSessionStorageDb extends EventEmitter implements IDb {
  * A database factory for testing that stores data in the browsers session storage
  */
 export class LocalSessionStorageDbFactory implements ITestDbFactory {
-    public readonly testDatabase: IDb;
-    constructor(namespace: string) {
-        this.testDatabase = new LocalSessionStorageDb(namespace);
-    }
+    public readonly testDatabase: IDb = new LocalSessionStorageDb();
     public async connect(): Promise<IDb> {
         return this.testDatabase;
     }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/local-driver";
-export const pkgVersion = "2.0.0-dev.1.4.5.105745";
+export const pkgVersion = "2.0.0-dev.2.2.0.111723";