@fluidframework/driver-utils 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/src/blobCacheStorageService.ts

@@ -1,32 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { IDocumentStorageService, IDocumentStorageServicePolicies } from "@fluidframework/driver-definitions";
-import { DocumentStorageServiceProxy } from "./documentStorageServiceProxy";
-
-/**
- * IDocumentStorageService adapter with pre-cached blobs.
- */
-export class BlobCacheStorageService extends DocumentStorageServiceProxy {
-    constructor(
-        internalStorageService: IDocumentStorageService,
-        private readonly blobs: Map<string, ArrayBufferLike>,
-    ) {
-        super(internalStorageService);
-    }
-
-    public get policies(): IDocumentStorageServicePolicies | undefined {
-        return this.internalStorageService.policies;
-    }
-
-    public async readBlob(id: string): Promise<ArrayBufferLike> {
-        const blob = this.blobs.get(id);
-        if (blob !== undefined) {
-            return blob;
-        }
-
-        return this.internalStorageService.readBlob(id);
-    }
-}

package/src/emptyDocumentDeltaStorageService.ts

@@ -1,24 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { IDocumentDeltaStorageService, IStream } from "@fluidframework/driver-definitions";
-import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import { Queue } from "./parallelRequests";
-
-/**
- * Implementation of IDocumentDeltaStorageService that will always return an empty message queue when fetching messages
- */
-export class EmptyDocumentDeltaStorageService implements IDocumentDeltaStorageService {
-    public fetchMessages(from: number,
-        _to: number | undefined,
-        _abortSignal?: AbortSignal,
-        _cachedOnly?: boolean,
-        _fetchReason?: string,
-    ): IStream<ISequencedDocumentMessage[]> {
-        const queue = new Queue<ISequencedDocumentMessage[]>();
-        queue.pushDone();
-        return queue;
-    }
-}

package/src/fluidResolvedUrl.ts

@@ -1,15 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { IResolvedUrl, IFluidResolvedUrl } from "@fluidframework/driver-definitions";
-
-export const isFluidResolvedUrl =
-    (resolved: IResolvedUrl | undefined): resolved is IFluidResolvedUrl => resolved?.type === "fluid";
-
-export function ensureFluidResolvedUrl(resolved: IResolvedUrl | undefined): asserts resolved is IFluidResolvedUrl {
-    if (!isFluidResolvedUrl(resolved)) {
-        throw new Error(`resolved is not a Fluid url. Type: ${resolved?.type}`);
-    }
-}

package/src/multiDocumentServiceFactory.ts

@@ -1,80 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { parse } from "url";
-import {
-    IDocumentServiceFactory,
-    IResolvedUrl,
-    IDocumentService,
-} from "@fluidframework/driver-definitions";
-import { ISummaryTree } from "@fluidframework/protocol-definitions";
-import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
-import { ensureFluidResolvedUrl } from "./fluidResolvedUrl";
-
-export class MultiDocumentServiceFactory implements IDocumentServiceFactory {
-    public static create(documentServiceFactory: IDocumentServiceFactory | IDocumentServiceFactory[]) {
-        if (Array.isArray(documentServiceFactory)) {
-            const factories: IDocumentServiceFactory[] = [];
-            documentServiceFactory.forEach((factory) => {
-                const maybeMulti = factory as MultiDocumentServiceFactory;
-                if (maybeMulti.protocolToDocumentFactoryMap !== undefined) {
-                    factories.push(...maybeMulti.protocolToDocumentFactoryMap.values());
-                } else {
-                    factories.push(factory);
-                }
-            });
-            if (factories.length === 1) {
-                return factories[0];
-            }
-            return new MultiDocumentServiceFactory(factories);
-        }
-        return documentServiceFactory;
-    }
-
-    private readonly protocolToDocumentFactoryMap: Map<string, IDocumentServiceFactory>;
-
-    constructor(documentServiceFactories: IDocumentServiceFactory[]) {
-        this.protocolToDocumentFactoryMap = new Map();
-        documentServiceFactories.forEach((factory: IDocumentServiceFactory) => {
-            this.protocolToDocumentFactoryMap.set(factory.protocolName, factory);
-        });
-    }
-    public readonly protocolName = "none:";
-    async createDocumentService(
-        resolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        ensureFluidResolvedUrl(resolvedUrl);
-        const urlObj = parse(resolvedUrl.url);
-        if (urlObj.protocol === undefined || urlObj.protocol === null) {
-            throw new Error("No protocol provided");
-        }
-        const factory: IDocumentServiceFactory | undefined = this.protocolToDocumentFactoryMap.get(urlObj.protocol);
-        if (factory === undefined) {
-            throw new Error("Unknown Fluid protocol");
-        }
-
-        return factory.createDocumentService(resolvedUrl, logger, clientIsSummarizer);
-    }
-
-    public async createContainer(
-        createNewSummary: ISummaryTree,
-        createNewResolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        ensureFluidResolvedUrl(createNewResolvedUrl);
-        const urlObj = parse(createNewResolvedUrl.url);
-        if (urlObj.protocol === undefined || urlObj.protocol === null) {
-            throw new Error("No protocol provided");
-        }
-        const factory: IDocumentServiceFactory | undefined = this.protocolToDocumentFactoryMap.get(urlObj.protocol);
-        if (factory === undefined) {
-            throw new Error("Unknown Fluid protocol");
-        }
-        return factory.createContainer(createNewSummary, createNewResolvedUrl, logger, clientIsSummarizer);
-    }
-}

package/src/multiUrlResolver.ts

@@ -1,51 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { IRequest } from "@fluidframework/core-interfaces";
-import { IResolvedUrl, IUrlResolver } from "@fluidframework/driver-definitions";
-
-/**
- * Resolver that takes a list of url resolvers and then try each of them to resolve the url.
- * @param resolversList - List of url resolvers to be used to resolve the request.
- * @param request - Request to be resolved.
- */
-export async function configurableUrlResolver(
-    resolversList: IUrlResolver[],
-    request: IRequest,
-): Promise<IResolvedUrl | undefined> {
-    let resolved: IResolvedUrl | undefined;
-    for (const resolver of resolversList) {
-        resolved = await resolver.resolve({ ...request });
-        if (resolved !== undefined) {
-            return resolved;
-        }
-    }
-    return undefined;
-}
-
-export class MultiUrlResolver implements IUrlResolver {
-    public static create(urlResolver: IUrlResolver | IUrlResolver[]) {
-        if (Array.isArray(urlResolver)) {
-            if (urlResolver.length === 1) {
-                return urlResolver[0];
-            }
-            return new MultiUrlResolver(urlResolver);
-        }
-        return urlResolver;
-    }
-
-    private constructor(private readonly urlResolvers: IUrlResolver[]) { }
-
-    async resolve(request: IRequest): Promise<IResolvedUrl | undefined> {
-        return configurableUrlResolver(this.urlResolvers, request);
-    }
-
-    public async getAbsoluteUrl(
-        resolvedUrl: IResolvedUrl,
-        relativeUrl: string,
-    ): Promise<string> {
-        throw new Error("Not implmented");
-    }
-}

package/src/treeUtils.ts

@@ -1,111 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import {
-    assert,
-    IsoBuffer,
-} from "@fluidframework/common-utils";
-import {
-    SummaryType,
-    ISnapshotTree,
-    ISummaryTree,
-    SummaryObject,
-} from "@fluidframework/protocol-definitions";
-
-/**
- * Summary tree assembler props
- */
-export interface ISummaryTreeAssemblerProps {
-    /**
-	 * Indicates that this tree is unreferenced. If this is not present, the tree is considered referenced.
-	 */
-    unreferenced?: true;
-}
-
-/**
- * Summary tree assembler (without stats collection).
- */
-export class SummaryTreeAssembler {
-    private attachmentCounter: number = 0;
-    private readonly summaryTree: { [path: string]: SummaryObject; } = {};
-
-    constructor(
-        private readonly props?: ISummaryTreeAssemblerProps,
-    ) { }
-
-    /**
-    * Get final summary
-    */
-    public get summary(): ISummaryTree {
-        return {
-            type: SummaryType.Tree,
-            tree: { ...this.summaryTree },
-            unreferenced: this.props?.unreferenced,
-        };
-    }
-
-    /**
-    * Add blob to summary
-    */
-    public addBlob(key: string, content: string | Uint8Array): void {
-        this.summaryTree[key] = {
-            type: SummaryType.Blob,
-            content,
-        };
-    }
-
-    /**
-    * Add handle to summary
-    */
-    public addHandle(
-        key: string,
-        handleType: SummaryType.Tree | SummaryType.Blob | SummaryType.Attachment,
-        handle: string): void {
-        this.summaryTree[key] = {
-            type: SummaryType.Handle,
-            handleType,
-            handle,
-        };
-    }
-
-    /**
-    * Add tree to summary
-    */
-    public addTree(key: string, summary: ISummaryTree): void {
-        this.summaryTree[key] = summary;
-    }
-
-    /**
-    * Add attachment to summary
-    */
-    public addAttachment(id: string) {
-        this.summaryTree[this.attachmentCounter++] = { id, type: SummaryType.Attachment };
-    }
-}
-
-/**
- * Helper function that converts ISnapshotTree and blobs to ISummaryTree
- * @param snapshot - Source snapshot tree
- * @param blobs - Blobs cache
- * @returns Converted snapshot in ISummaryTree format
- */
-export function convertSnapshotAndBlobsToSummaryTree(
-    snapshot: ISnapshotTree,
-    blobs: Map<string, ArrayBuffer>,
-): ISummaryTree {
-    const assembler = new SummaryTreeAssembler({
-        unreferenced: snapshot.unreferenced,
-    });
-    for (const [path, id] of Object.entries(snapshot.blobs)) {
-        const blob = blobs.get(id);
-        assert(blob !== undefined, 0x2dd /* "Cannot find blob for a given id" */);
-        assembler.addBlob(path, IsoBuffer.from(blob).toString("utf-8"));
-    }
-    for (const [key, tree] of Object.entries(snapshot.trees)) {
-        const subtree = convertSnapshotAndBlobsToSummaryTree(tree, blobs);
-        assembler.addTree(key, subtree);
-    }
-    return assembler.summary;
-}

package/tsconfig.esnext.json

@@ -1,7 +0,0 @@
-{
-    "extends": "./tsconfig.json",
-    "compilerOptions": {
-        "outDir": "./lib",
-        "module": "esnext"
-    },
-}