@fluidframework/local-driver 1.4.0-115997 → 2.0.0-dev-rc.1.0.0.224419

package/src/localCreateDocument.ts

@@ -0,0 +1,48 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IResolvedUrl } from "@fluidframework/driver-definitions";
+import {
+	getDocAttributesFromProtocolSummary,
+	getQuorumValuesFromProtocolSummary,
+	isCombinedAppAndProtocolSummary,
+} from "@fluidframework/driver-utils";
+import { ISummaryTree } from "@fluidframework/protocol-definitions";
+import { LocalDeltaConnectionServer } from "@fluidframework/server-local-server";
+import { defaultHash } from "@fluidframework/server-services-client";
+
+export async function createDocument(
+	localDeltaConnectionServer,
+	resolvedUrl: IResolvedUrl,
+	summary: ISummaryTree,
+) {
+	const pathName = new URL(resolvedUrl.url).pathname;
+	const pathArr = pathName.split("/");
+	const tenantId = pathArr[pathArr.length - 2];
+	const id = pathArr[pathArr.length - 1];
+	const documentStorage = (localDeltaConnectionServer as LocalDeltaConnectionServer)
+		.documentStorage;
+	if (!isCombinedAppAndProtocolSummary(summary)) {
+		throw new Error("Protocol and App Summary required in the full summary");
+	}
+	const protocolSummary = summary.tree[".protocol"];
+	const appSummary = summary.tree[".app"];
+	const documentAttributes = getDocAttributesFromProtocolSummary(protocolSummary);
+	const quorumValues = getQuorumValuesFromProtocolSummary(protocolSummary);
+	const sequenceNumber = documentAttributes.sequenceNumber;
+	await documentStorage.createDocument(
+		tenantId,
+		id,
+		appSummary,
+		sequenceNumber,
+		defaultHash,
+		resolvedUrl.endpoints.ordererUrl ?? "",
+		resolvedUrl.endpoints.storageUrl ?? "",
+		resolvedUrl.endpoints.deltaStorageUrl ?? "",
+		quorumValues,
+		false /* enableDiscovery */,
+		false /* isEphemeralContainer */,
+	);
+}

package/src/localDeltaStorageService.ts

@@ -3,42 +3,43 @@
  * Licensed under the MIT License.
  */
 
-import * as api from "@fluidframework/driver-definitions";
+import { IDocumentDeltaStorageService, IStream } from "@fluidframework/driver-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { IDatabaseManager } from "@fluidframework/server-services-core";
 import { streamFromMessages } from "@fluidframework/driver-utils";
 
 /**
  * Provides access to the underlying delta storage on the server for local driver.
+ * @internal
  */
-export class LocalDeltaStorageService implements api.IDocumentDeltaStorageService {
-    constructor(
-        private readonly tenantId: string,
-        private readonly id: string,
-        private readonly databaseManager: IDatabaseManager) {
-    }
+export class LocalDeltaStorageService implements IDocumentDeltaStorageService {
+	constructor(
+		private readonly tenantId: string,
+		private readonly id: string,
+		private readonly databaseManager: IDatabaseManager,
+	) {}
 
-    public fetchMessages(
-        from: number,
-        to: number | undefined,
-        abortSignal?: AbortSignal,
-        cachedOnly?: boolean,
-    ): api.IStream<ISequencedDocumentMessage[]> {
-            return streamFromMessages(this.getCore(from, to));
-    }
+	public fetchMessages(
+		from: number,
+		to: number | undefined,
+		abortSignal?: AbortSignal,
+		cachedOnly?: boolean,
+	): IStream<ISequencedDocumentMessage[]> {
+		return streamFromMessages(this.getCore(from, to));
+	}
 
-    private async getCore(from: number, to?: number) {
-        const query = { documentId: this.id, tenantId: this.tenantId };
-        query["operation.sequenceNumber"] = {};
-        query["operation.sequenceNumber"].$gt = from - 1; // from is inclusive
+	private async getCore(from: number, to?: number) {
+		const query = { documentId: this.id, tenantId: this.tenantId };
+		query["operation.sequenceNumber"] = {};
+		query["operation.sequenceNumber"].$gt = from - 1; // from is inclusive
 
-        // This looks like a bug. It used to work without setting $lt key. Now it does not
-        // Need follow up
-        query["operation.sequenceNumber"].$lt = to ?? Number.MAX_SAFE_INTEGER;
+		// This looks like a bug. It used to work without setting $lt key. Now it does not
+		// Need follow up
+		query["operation.sequenceNumber"].$lt = to ?? Number.MAX_SAFE_INTEGER;
 
-        const allDeltas = await this.databaseManager.getDeltaCollection(this.tenantId, this.id);
-        const dbDeltas = await allDeltas.find(query, { "operation.sequenceNumber": 1 });
-        const messages = dbDeltas.map((delta) => delta.operation);
-        return messages;
-    }
+		const allDeltas = await this.databaseManager.getDeltaCollection(this.tenantId, this.id);
+		const dbDeltas = await allDeltas.find(query, { "operation.sequenceNumber": 1 });
+		const messages = dbDeltas.map((delta) => delta.operation);
+		return messages;
+	}
 }

package/src/localDocumentDeltaConnection.ts

@@ -3,112 +3,115 @@
  * Licensed under the MIT License.
  */
 
-import { TelemetryNullLogger } from "@fluidframework/common-utils";
 import { DocumentDeltaConnection } from "@fluidframework/driver-base";
 import {
-    IClient,
-    IConnect,
-    IDocumentMessage,
-    NackErrorType,
+	IClient,
+	IConnect,
+	IDocumentMessage,
+	NackErrorType,
 } from "@fluidframework/protocol-definitions";
+import { createChildLogger } from "@fluidframework/telemetry-utils";
 import { LocalWebSocketServer } from "@fluidframework/server-local-server";
-import * as core from "@fluidframework/server-services-core";
+import { IWebSocketServer } from "@fluidframework/server-services-core";
 import type { Socket } from "socket.io-client";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 
 const testProtocolVersions = ["^0.3.0", "^0.2.0", "^0.1.0"];
 
 /**
  * Represents a connection to a stream of delta updates
+ * @internal
  */
 export class LocalDocumentDeltaConnection extends DocumentDeltaConnection {
-    /**
-     * Create a LocalDocumentDeltaConnection
-     * Handle initial messages, contents or signals if they were in queue
-     *
-     * @param tenantId - the ID of the tenant
-     * @param id - document ID
-     * @param token - authorization token for storage service
-     * @param client - information about the client
-     * @param webSocketServer - web socket server to create connection
-     */
-    public static async create(
-        tenantId: string,
-        id: string,
-        token: string,
-        client: IClient,
-        webSocketServer: core.IWebSocketServer,
-        timeoutMs = 60000,
-    ): Promise<LocalDocumentDeltaConnection> {
-        const socket = (webSocketServer as LocalWebSocketServer).createConnection();
+	/**
+	 * Create a LocalDocumentDeltaConnection
+	 * Handle initial messages, contents or signals if they were in queue
+	 *
+	 * @param tenantId - the ID of the tenant
+	 * @param id - document ID
+	 * @param token - authorization token for storage service
+	 * @param client - information about the client
+	 * @param webSocketServer - web socket server to create connection
+	 */
+	public static async create(
+		tenantId: string,
+		id: string,
+		token: string,
+		client: IClient,
+		webSocketServer: IWebSocketServer,
+		timeoutMs = 60000,
+		logger?: ITelemetryBaseLogger,
+	): Promise<LocalDocumentDeltaConnection> {
+		const socket = (webSocketServer as LocalWebSocketServer).createConnection();
 
-        // Cast LocalWebSocket to SocketIOClient.Socket which is the socket that the base class needs. This is hacky
-        // but should be fine because this delta connection is for local use only.
-        const socketWithListener = socket as unknown as Socket;
+		// Cast LocalWebSocket to SocketIOClient.Socket which is the socket that the base class needs. This is hacky
+		// but should be fine because this delta connection is for local use only.
+		const socketWithListener = socket as unknown as Socket;
 
-        const deltaConnection = new LocalDocumentDeltaConnection(socketWithListener, id);
+		const deltaConnection = new LocalDocumentDeltaConnection(socketWithListener, id, logger);
 
-        const connectMessage: IConnect = {
-            client,
-            id,
-            mode: client.mode,
-            tenantId,
-            token,  // Token is going to indicate tenant level information, etc...
-            versions: testProtocolVersions,
-        };
-        await deltaConnection.initialize(connectMessage, timeoutMs);
-        return deltaConnection;
-    }
+		const connectMessage: IConnect = {
+			client,
+			id,
+			mode: client.mode,
+			tenantId,
+			token, // Token is going to indicate tenant level information, etc...
+			versions: testProtocolVersions,
+		};
+		await deltaConnection.initialize(connectMessage, timeoutMs);
+		return deltaConnection;
+	}
 
-    constructor(socket: Socket, documentId: string) {
-          super(socket, documentId, new TelemetryNullLogger());
-    }
+	constructor(socket: Socket, documentId: string, logger?: ITelemetryBaseLogger) {
+		super(socket, documentId, createChildLogger({ logger }));
+	}
 
-    protected submitCore(type: string, messages: IDocumentMessage[]) {
-        this.emitMessages(type, [messages]);
-    }
+	/**
+	 * Submits a new delta operation to the server
+	 */
+	public submit(messages: IDocumentMessage[]): void {
+		// We use a promise resolve to force a turn break given message processing is sync
+		// eslint-disable-next-line @typescript-eslint/no-floating-promises
+		Promise.resolve().then(() => {
+			this.emitMessages("submitOp", [messages]);
+		});
+	}
 
-    /**
-     * Submits a new delta operation to the server
-     */
-    public submit(messages: IDocumentMessage[]): void {
-        // We use a promise resolve to force a turn break given message processing is sync
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        Promise.resolve().then(() => {
-            this.submitCore("submitOp", messages);
-        });
-    }
+	/**
+	 * Submits a new signal to the server
+	 */
+	public submitSignal(message: any): void {
+		this.emitMessages("submitSignal", [[message]]);
+	}
 
-    /**
-     * Submits a new signal to the server
-     */
-    public submitSignal(message: any): void {
-        this.submitCore("submitSignal", [message]);
-    }
+	/**
+	 * Send a "disconnect" message on the socket.
+	 * @param disconnectReason - The reason of the disconnection.
+	 */
+	public disconnectClient(disconnectReason: string) {
+		this.socket.emit("disconnect", disconnectReason);
+	}
 
-    /**
-     * Send a "disconnect" message on the socket.
-     * @param disconnectReason - The reason of the disconnection.
-     */
-    public disconnectClient(disconnectReason: string) {
-        this.socket.emit("disconnect", disconnectReason);
-    }
-
-    /**
-     * * Sends a "nack" message on the socket.
-     * @param code - An error code number that represents the error. It will be a valid HTTP error code.
-     * @param type - Type of the Nack.
-     * @param message - A message about the nack for debugging/logging/telemetry purposes.
-     */
-    public nackClient(code: number = 400, type: NackErrorType = NackErrorType.ThrottlingError, message: any) {
-        const nackMessage = {
-            operation: undefined,
-            sequenceNumber: -1,
-            content: {
-                code,
-                type,
-                message,
-            },
-        };
-        this.socket.emit("nack", "", [nackMessage]);
-    }
+	/**
+	 * * Sends a "nack" message on the socket.
+	 * @param code - An error code number that represents the error. It will be a valid HTTP error code.
+	 * @param type - Type of the Nack.
+	 * @param message - A message about the nack for debugging/logging/telemetry purposes.
+	 */
+	public nackClient(
+		code: number = 400,
+		type: NackErrorType = NackErrorType.ThrottlingError,
+		message: any,
+	) {
+		const nackMessage = {
+			operation: undefined,
+			sequenceNumber: -1,
+			content: {
+				code,
+				type,
+				message,
+			},
+		};
+		this.socket.emit("nack", "", [nackMessage]);
+	}
 }

package/src/localDocumentService.ts

@@ -3,100 +3,116 @@
  * Licensed under the MIT License.
  */
 
-import * as api from "@fluidframework/driver-definitions";
+import {
+	IDocumentDeltaConnection,
+	IDocumentDeltaStorageService,
+	IDocumentService,
+	IDocumentServicePolicies,
+	IDocumentStorageService,
+	IResolvedUrl,
+} from "@fluidframework/driver-definitions";
 import { IClient } from "@fluidframework/protocol-definitions";
-import * as socketStorage from "@fluidframework/routerlicious-driver";
+import { ITokenProvider } from "@fluidframework/routerlicious-driver";
 import { GitManager } from "@fluidframework/server-services-client";
 import { TestHistorian } from "@fluidframework/server-test-utils";
 import { ILocalDeltaConnectionServer } from "@fluidframework/server-local-server";
-import { TelemetryNullLogger } from "@fluidframework/common-utils";
-import { LocalDeltaStorageService, LocalDocumentDeltaConnection } from ".";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { LocalDocumentStorageService } from "./localDocumentStorageService";
+import { LocalDocumentDeltaConnection } from "./localDocumentDeltaConnection";
+import { LocalDeltaStorageService } from "./localDeltaStorageService";
 
 /**
  * Basic implementation of a document service for local use.
+ * @internal
  */
-export class LocalDocumentService implements api.IDocumentService {
-    /**
-     * @param localDeltaConnectionServer - delta connection server for ops
-     * @param tokenProvider - token provider
-     * @param tenantId - ID of tenant
-     * @param documentId - ID of document
-     */
-    constructor(
-        public readonly resolvedUrl: api.IResolvedUrl,
-        private readonly localDeltaConnectionServer: ILocalDeltaConnectionServer,
-        private readonly tokenProvider: socketStorage.ITokenProvider,
-        private readonly tenantId: string,
-        private readonly documentId: string,
-        private readonly documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
-        public readonly policies: api.IDocumentServicePolicies = {},
-        private readonly innerDocumentService?: api.IDocumentService,
-    ) { }
+export class LocalDocumentService implements IDocumentService {
+	/**
+	 * @param localDeltaConnectionServer - delta connection server for ops
+	 * @param tokenProvider - token provider
+	 * @param tenantId - ID of tenant
+	 * @param documentId - ID of document
+	 */
+	constructor(
+		public readonly resolvedUrl: IResolvedUrl,
+		private readonly localDeltaConnectionServer: ILocalDeltaConnectionServer,
+		private readonly tokenProvider: ITokenProvider,
+		private readonly tenantId: string,
+		private readonly documentId: string,
+		private readonly documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
+		public readonly policies: IDocumentServicePolicies = {},
+		private readonly innerDocumentService?: IDocumentService,
+		private readonly logger?: ITelemetryBaseLogger,
+	) {}
 
-    public dispose() { }
+	public dispose() {}
 
-    /**
-     * Creates and returns a document storage service for local use.
-     */
-    public async connectToStorage(): Promise<api.IDocumentStorageService> {
-        return new socketStorage.DocumentStorageService(
-            this.documentId,
-            new GitManager(new TestHistorian(this.localDeltaConnectionServer.testDbFactory.testDatabase)),
-            new TelemetryNullLogger(),
-            { minBlobSize: 2048 }, // Test blob aggregation.
-            undefined,
-            undefined,
-            undefined,
-            new GitManager(new TestHistorian(this.localDeltaConnectionServer.testDbFactory.testDatabase)));
-    }
+	/**
+	 * Creates and returns a document storage service for local use.
+	 */
+	public async connectToStorage(): Promise<IDocumentStorageService> {
+		return new LocalDocumentStorageService(
+			this.documentId,
+			new GitManager(
+				new TestHistorian(this.localDeltaConnectionServer.testDbFactory.testDatabase),
+			),
+			{
+				maximumCacheDurationMs: 432_000_000, // 5 days in ms. Not actually enforced but shouldn't matter for any local driver scenario
+			},
+			this.localDeltaConnectionServer,
+			this.resolvedUrl,
+		);
+	}
 
-    /**
-     * Creates and returns a delta storage service for local use.
-     */
-    public async connectToDeltaStorage(): Promise<api.IDocumentDeltaStorageService> {
-        if (this.innerDocumentService) {
-            return this.innerDocumentService.connectToDeltaStorage();
-        }
-        return new LocalDeltaStorageService(
-            this.tenantId,
-            this.documentId,
-            this.localDeltaConnectionServer.databaseManager);
-    }
+	/**
+	 * Creates and returns a delta storage service for local use.
+	 */
+	public async connectToDeltaStorage(): Promise<IDocumentDeltaStorageService> {
+		if (this.innerDocumentService) {
+			return this.innerDocumentService.connectToDeltaStorage();
+		}
+		return new LocalDeltaStorageService(
+			this.tenantId,
+			this.documentId,
+			this.localDeltaConnectionServer.databaseManager,
+		);
+	}
 
-    /**
-     * Creates and returns a delta stream for local use.
-     * @param client - client data
-     */
-    public async connectToDeltaStream(client: IClient): Promise<api.IDocumentDeltaConnection> {
-        if (this.policies.storageOnly === true) {
-            throw new Error("can't connect to delta stream in storage-only mode");
-        }
-        if (this.innerDocumentService) {
-            return this.innerDocumentService.connectToDeltaStream(client);
-        }
-        const ordererToken = await this.tokenProvider.fetchOrdererToken(
-            this.tenantId,
-            this.documentId,
-        );
-        const documentDeltaConnection = await LocalDocumentDeltaConnection.create(
-            this.tenantId,
-            this.documentId,
-            ordererToken.jwt,
-            client,
-            this.localDeltaConnectionServer.webSocketServer,
-        );
-        const clientId = documentDeltaConnection.clientId;
+	/**
+	 * Creates and returns a delta stream for local use.
+	 * @param client - client data
+	 */
+	public async connectToDeltaStream(client: IClient): Promise<IDocumentDeltaConnection> {
+		if (this.policies.storageOnly === true) {
+			throw new Error("can't connect to delta stream in storage-only mode");
+		}
+		if (this.innerDocumentService) {
+			return this.innerDocumentService.connectToDeltaStream(client);
+		}
+		const ordererToken = await this.tokenProvider.fetchOrdererToken(
+			this.tenantId,
+			this.documentId,
+		);
+		const documentDeltaConnection = await LocalDocumentDeltaConnection.create(
+			this.tenantId,
+			this.documentId,
+			ordererToken.jwt,
+			client,
+			this.localDeltaConnectionServer.webSocketServer,
+			undefined,
+			this.logger,
+		);
+		const clientId = documentDeltaConnection.clientId;
 
-        // Add this document service for the clientId in the document service factory.
-        this.documentDeltaConnectionsMap.set(clientId, documentDeltaConnection);
+		// Add this document service for the clientId in the document service factory.
+		this.documentDeltaConnectionsMap.set(clientId, documentDeltaConnection);
 
-        // Add a listener to remove this document service when the client is disconnected.
-        documentDeltaConnection.on("disconnect", () => {
-            this.documentDeltaConnectionsMap.delete(clientId);
-        });
+		// Add a listener to remove this document service when the client is disconnected.
+		documentDeltaConnection.on("disconnect", () => {
+			this.documentDeltaConnectionsMap.delete(clientId);
+		});
 
-        return documentDeltaConnection;
-    }
+		return documentDeltaConnection;
+	}
 }
 
 /**
@@ -105,24 +121,28 @@ export class LocalDocumentService implements api.IDocumentService {
  * @param tokenProvider - token provider with a single token
  * @param tenantId - ID of tenant
  * @param documentId - ID of document
+ * @internal
  */
 export function createLocalDocumentService(
-    resolvedUrl: api.IResolvedUrl,
-    localDeltaConnectionServer: ILocalDeltaConnectionServer,
-    tokenProvider: socketStorage.ITokenProvider,
-    tenantId: string,
-    documentId: string,
-    documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
-    policies?: api.IDocumentServicePolicies,
-    innerDocumentService?: api.IDocumentService): api.IDocumentService {
-    return new LocalDocumentService(
-        resolvedUrl,
-        localDeltaConnectionServer,
-        tokenProvider,
-        tenantId,
-        documentId,
-        documentDeltaConnectionsMap,
-        policies,
-        innerDocumentService,
-    );
+	resolvedUrl: IResolvedUrl,
+	localDeltaConnectionServer: ILocalDeltaConnectionServer,
+	tokenProvider: ITokenProvider,
+	tenantId: string,
+	documentId: string,
+	documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
+	policies?: IDocumentServicePolicies,
+	innerDocumentService?: IDocumentService,
+	logger?: ITelemetryBaseLogger,
+): IDocumentService {
+	return new LocalDocumentService(
+		resolvedUrl,
+		localDeltaConnectionServer,
+		tokenProvider,
+		tenantId,
+		documentId,
+		documentDeltaConnectionsMap,
+		policies,
+		innerDocumentService,
+		logger,
+	);
 }