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

package/src/localResolver.ts

@@ -4,81 +4,79 @@
  */
 
 import { parse } from "url";
-import { assert } from "@fluidframework/common-utils";
+import { assert } from "@fluidframework/core-utils";
 import { IRequest } from "@fluidframework/core-interfaces";
-import {
-    IFluidResolvedUrl,
-    IResolvedUrl,
-    IUrlResolver,
-    DriverHeader,
-} from "@fluidframework/driver-definitions";
+import { IResolvedUrl, IUrlResolver, DriverHeader } from "@fluidframework/driver-definitions";
 import { ScopeType } from "@fluidframework/protocol-definitions";
 import { generateToken } from "./auth";
 
+/**
+ * @alpha
+ */
 export function createLocalResolverCreateNewRequest(documentId: string): IRequest {
-    const createNewRequest: IRequest = {
-        url: `http://localhost:3000/${documentId}`,
-        headers: {
-            [DriverHeader.createNew]: true,
-        },
-    };
-    return createNewRequest;
+	const createNewRequest: IRequest = {
+		url: `http://localhost:3000/${documentId}`,
+		headers: {
+			[DriverHeader.createNew]: true,
+		},
+	};
+	return createNewRequest;
 }
 
 /**
  * Resolves URLs by providing fake URLs which succeed with the other
  * related local classes.
+ * @alpha
  */
 export class LocalResolver implements IUrlResolver {
-    private readonly tenantId = "tenantId";
-    private readonly tokenKey = "tokenKey";
-
-    constructor() { }
+	private readonly tenantId = "tenantId";
+	private readonly tokenKey = "tokenKey";
 
-    /**
-     * Resolves URL requests by providing fake URLs with an actually generated
-     * token from constant test strings. The root of the URL is fake, but the
-     * remaining relative URL can still be parsed.
-     * @param request - request to handle
-     */
-    public async resolve(request: IRequest): Promise<IResolvedUrl> {
-        const parsedUrl = new URL(request.url);
-        const fullPath = `${parsedUrl.pathname.substr(1)}${parsedUrl.search}`;
-        const documentId = fullPath.split("/")[0];
-        const scopes = [ScopeType.DocRead, ScopeType.DocWrite, ScopeType.SummaryWrite];
-        const resolved: IFluidResolvedUrl = {
-            endpoints: {
-                deltaStorageUrl: `http://localhost:3000/deltas/${this.tenantId}/${documentId}`,
-                ordererUrl: "http://localhost:3000",
-                storageUrl: `http://localhost:3000/repos/${this.tenantId}`,
-            },
-            id: documentId,
-            tokens: { jwt: generateToken(this.tenantId, documentId, this.tokenKey, scopes) },
-            type: "fluid",
-            url: `fluid-test://localhost:3000/${this.tenantId}/${fullPath}`,
-        };
+	constructor() {}
 
-        return resolved;
-    }
+	/**
+	 * Resolves URL requests by providing fake URLs with an actually generated
+	 * token from constant test strings. The root of the URL is fake, but the
+	 * remaining relative URL can still be parsed.
+	 * @param request - request to handle
+	 * @alpha
+	 */
+	public async resolve(request: IRequest): Promise<IResolvedUrl> {
+		const parsedUrl = new URL(request.url);
+		const fullPath = `${parsedUrl.pathname.substr(1)}${parsedUrl.search}`;
+		const documentId = fullPath.split("/")[0];
+		const scopes = [ScopeType.DocRead, ScopeType.DocWrite, ScopeType.SummaryWrite];
+		const resolved: IResolvedUrl = {
+			endpoints: {
+				deltaStorageUrl: `http://localhost:3000/deltas/${this.tenantId}/${documentId}`,
+				ordererUrl: "http://localhost:3000",
+				storageUrl: `http://localhost:3000/repos/${this.tenantId}`,
+			},
+			id: documentId,
+			tokens: { jwt: generateToken(this.tenantId, documentId, this.tokenKey, scopes) },
+			type: "fluid",
+			url: `fluid-test://localhost:3000/${this.tenantId}/${fullPath}`,
+		};
 
-    public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
-        let url = relativeUrl;
-        if (url.startsWith("/")) {
-            url = url.substr(1);
-        }
-        const fluidResolvedUrl = resolvedUrl as IFluidResolvedUrl;
+		return resolved;
+	}
 
-        const parsedUrl = parse(fluidResolvedUrl.url);
-        if (parsedUrl.pathname === null) {
-            throw new Error("Url should contain tenant and docId!!");
-        }
-        const [, , documentId] = parsedUrl.pathname.split("/");
-        assert(!!documentId, 0x09a /* "'documentId' must be a defined, non-zero length string." */);
+	public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
+		let url = relativeUrl;
+		if (url.startsWith("/")) {
+			url = url.substr(1);
+		}
+		const parsedUrl = parse(resolvedUrl.url);
+		if (parsedUrl.pathname === null) {
+			throw new Error("Url should contain tenant and docId!!");
+		}
+		const [, , documentId] = parsedUrl.pathname.split("/");
+		assert(!!documentId, 0x09a /* "'documentId' must be a defined, non-zero length string." */);
 
-        return `http://localhost:3000/${documentId}/${url}`;
-    }
+		return `http://localhost:3000/${documentId}/${url}`;
+	}
 
-    public createCreateNewRequest(documentId: string): IRequest {
-        return createLocalResolverCreateNewRequest(documentId);
-    }
+	public createCreateNewRequest(documentId: string): IRequest {
+		return createLocalResolverCreateNewRequest(documentId);
+	}
 }