@fluidframework/local-driver 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.225277

package/src/auth.ts

@@ -6,47 +6,56 @@
 import { ITokenClaims, IUser, ScopeType } from "@fluidframework/protocol-definitions";
 import { KJUR as jsrsasign } from "jsrsasign";
 import { v4 as uuid } from "uuid";
-import { getRandomName } from "@fluidframework/server-services-client";
 
 /**
  * Generates a JWT token to authorize against. We do not use the implementation in
  * services-client since it cannot run in the browser without polyfills.
  */
 export function generateToken(
-    tenantId: string,
-    documentId: string,
-    key: string,
-    scopes: ScopeType[],
-    user?: IUser,
-    lifetime: number = 60 * 60,
-    ver: string = "1.0"): string {
-    let userClaim = (user) ? user : generateUser();
-    if (userClaim.id === "" || userClaim.id === undefined) {
-        userClaim = generateUser();
-    }
-
-    // Current time in seconds
-    const now = Math.round((new Date()).getTime() / 1000);
-
-    const claims: ITokenClaims = {
-        documentId,
-        scopes,
-        tenantId,
-        user: userClaim,
-        iat: now,
-        exp: now + lifetime,
-        ver,
-    };
-
-    const utf8Key = { utf8: key };
-    return jsrsasign.jws.JWS.sign(null, JSON.stringify({ alg: "HS256", typ: "JWT" }), claims, utf8Key);
+	tenantId: string,
+	documentId: string,
+	key: string,
+	scopes: ScopeType[],
+	user?: IUser,
+	lifetime: number = 60 * 60,
+	ver: string = "1.0",
+): string {
+	let userClaim = user ? user : generateUser();
+	if (userClaim.id === "" || userClaim.id === undefined) {
+		userClaim = generateUser();
+	}
+
+	// Current time in seconds
+	const now = Math.round(new Date().getTime() / 1000);
+
+	const claims: ITokenClaims = {
+		documentId,
+		scopes,
+		tenantId,
+		user: userClaim,
+		iat: now,
+		exp: now + lifetime,
+		ver,
+	};
+
+	const utf8Key = { utf8: key };
+	return jsrsasign.jws.JWS.sign(
+		null,
+		JSON.stringify({ alg: "HS256", typ: "JWT" }),
+		claims,
+		utf8Key,
+	);
 }
 
 export function generateUser(): IUser {
-    const randomUser = {
-        id: uuid(),
-        name: getRandomName(" ", true),
-    };
+	const userId = uuid();
+	const match = userId.match(/^([\da-f]{8})-([\da-f]{4})/);
+	const userName = match !== null ? match[0] : userId; // Just use the first two segments of the (fake) userId as a fake name.
+
+	const randomUser = {
+		id: userId,
+		name: userName,
+	};
 
-    return randomUser;
+	return randomUser;
 }

package/src/index.ts

@@ -3,9 +3,10 @@
  * Licensed under the MIT License.
  */
 
-export * from "./localDeltaStorageService";
-export * from "./localDocumentDeltaConnection";
-export * from "./localDocumentService";
-export * from "./localDocumentServiceFactory";
-export * from "./localResolver";
-export * from "./localSessionStorageDb";
+export { LocalDeltaStorageService } from "./localDeltaStorageService";
+export { LocalDocumentDeltaConnection } from "./localDocumentDeltaConnection";
+export { createLocalDocumentService, LocalDocumentService } from "./localDocumentService";
+export { LocalDocumentServiceFactory } from "./localDocumentServiceFactory";
+export { LocalDocumentStorageService } from "./localDocumentStorageService";
+export { createLocalResolverCreateNewRequest, LocalResolver } from "./localResolver";
+export { LocalSessionStorageDbFactory } from "./localSessionStorageDb";

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]);
+	}
 }