@fluidframework/driver-definitions 2.0.0-dev.6.4.0.192049 → 2.0.0-dev.7.2.0.204906

package/CHANGELOG.md

@@ -1,5 +1,79 @@
 # @fluidframework/driver-definitions
 
+## 2.0.0-internal.7.1.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.0.0
+
+### Major Changes
+
+-   odsp-driver: Load container in readonly mode when driver throws DriverErrorType.outOfStorage [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    Handle DriverErrorType.outOfStorage error from driver and load the container in readonly mode. Currently there is no
+    handling and when the join session throws this error, the container will get closed. With this we use NoDeltaStream
+    object as connection and load the container in read mode, so that it loads properly. We also notify the that the
+    container is "readonly" through the event on delta manager so that apps can listen to this and show any UX etc. The app
+    can listen to the event like this:
+
+    ```ts
+    container.deltaManager.on(
+    	"readonly",
+    	(readonly?: boolean, readonlyConnectionReason?: { text: string; error?: IErrorBase }) => {
+    		// error?.errorType will be equal to DriverErrorType.outOfStorage in this case
+    		// App logic
+    	},
+    );
+    ```
+
+-   Dependencies on @fluidframework/protocol-definitions package updated to 3.0.0 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    This included the following changes from the protocol-definitions release:
+
+    -   Updating signal interfaces for some planned improvements. The intention is split the interface between signals
+        submitted by clients to the server and the resulting signals sent from the server to clients.
+        -   A new optional type member is available on the ISignalMessage interface and a new ISentSignalMessage interface has
+            been added, which will be the typing for signals sent from the client to the server. Both extend a new
+            ISignalMessageBase interface that contains common members.
+    -   The @fluidframework/common-definitions package dependency has been updated to version 1.0.0.
+
+-   routerlicious-driver: remove dead blob aggregation concepts and code [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    Dead concepts blob aggregation like `aggregateBlobsSmallerThanBytes` and `minBlobSize` have been removed.
+
+-   Server upgrade: dependencies on Fluid server packages updated to 2.0.1 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    Dependencies on the following Fluid server package have been updated to version 2.0.1:
+
+    -   @fluidframework/gitresources: 2.0.1
+    -   @fluidframework/server-kafka-orderer: 2.0.1
+    -   @fluidframework/server-lambdas: 2.0.1
+    -   @fluidframework/server-lambdas-driver: 2.0.1
+    -   @fluidframework/server-local-server: 2.0.1
+    -   @fluidframework/server-memory-orderer: 2.0.1
+    -   @fluidframework/protocol-base: 2.0.1
+    -   @fluidframework/server-routerlicious: 2.0.1
+    -   @fluidframework/server-routerlicious-base: 2.0.1
+    -   @fluidframework/server-services: 2.0.1
+    -   @fluidframework/server-services-client: 2.0.1
+    -   @fluidframework/server-services-core: 2.0.1
+    -   @fluidframework/server-services-ordering-kafkanode: 2.0.1
+    -   @fluidframework/server-services-ordering-rdkafka: 2.0.1
+    -   @fluidframework/server-services-ordering-zookeeper: 2.0.1
+    -   @fluidframework/server-services-shared: 2.0.1
+    -   @fluidframework/server-services-telemetry: 2.0.1
+    -   @fluidframework/server-services-utils: 2.0.1
+    -   @fluidframework/server-test-utils: 2.0.1
+    -   tinylicious: 2.0.1
+
+-   Minimum TypeScript version now 5.1.6 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    The minimum supported TypeScript version for Fluid 2.0 clients is now 5.1.6.
+
+## 2.0.0-internal.6.4.0
+
+Dependency updates only.
+
 ## 2.0.0-internal.6.3.0
 
 ### Minor Changes

package/api-extractor.json

@@ -1,4 +1,12 @@
 {
 	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "@fluidframework/build-common/api-extractor-common-strict.json"
+	"extends": "@fluidframework/build-common/api-extractor-base.json",
+	"messages": {
+		"extractorMessageReporting": {
+			"ae-missing-release-tag": {
+				// TODO: Fix violations and remove this rule override
+				"logLevel": "none"
+			}
+		}
+	}
 }

package/api-report/driver-definitions.api.md

@@ -0,0 +1,320 @@
+## API Report File for "@fluidframework/driver-definitions"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { ConnectionMode } from '@fluidframework/protocol-definitions';
+import { IClient } from '@fluidframework/protocol-definitions';
+import { IClientConfiguration } from '@fluidframework/protocol-definitions';
+import { ICreateBlobResponse } from '@fluidframework/protocol-definitions';
+import { IDisposable } from '@fluidframework/core-interfaces';
+import { IDocumentMessage } from '@fluidframework/protocol-definitions';
+import { IErrorEvent } from '@fluidframework/core-interfaces';
+import { IEventProvider } from '@fluidframework/core-interfaces';
+import { INack } from '@fluidframework/protocol-definitions';
+import { IRequest } from '@fluidframework/core-interfaces';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISignalClient } from '@fluidframework/protocol-definitions';
+import { ISignalMessage } from '@fluidframework/protocol-definitions';
+import { ISnapshotTree } from '@fluidframework/protocol-definitions';
+import { ISummaryHandle } from '@fluidframework/protocol-definitions';
+import { ISummaryTree } from '@fluidframework/protocol-definitions';
+import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import { ITokenClaims } from '@fluidframework/protocol-definitions';
+import { IVersion } from '@fluidframework/protocol-definitions';
+
+// @public (undocumented)
+export type DriverError = IThrottlingWarning | IGenericNetworkError | IAuthorizationError | ILocationRedirectionError | IDriverBasicError;
+
+// @public @deprecated
+export enum DriverErrorType {
+    authorizationError = "authorizationError",
+    deltaStreamConnectionForbidden = "deltaStreamConnectionForbidden",
+    fetchFailure = "fetchFailure",
+    fetchTokenError = "fetchTokenError",
+    fileIsLocked = "fileIsLocked",
+    fileNotFoundOrAccessDeniedError = "fileNotFoundOrAccessDeniedError",
+    fileOverwrittenInStorage = "fileOverwrittenInStorage",
+    fluidInvalidSchema = "fluidInvalidSchema",
+    genericError = "genericError",
+    genericNetworkError = "genericNetworkError",
+    incorrectServerResponse = "incorrectServerResponse",
+    locationRedirection = "locationRedirection",
+    offlineError = "offlineError",
+    outOfStorageError = "outOfStorageError",
+    throttlingError = "throttlingError",
+    // (undocumented)
+    unsupportedClientProtocolVersion = "unsupportedClientProtocolVersion",
+    usageError = "usageError",
+    writeError = "writeError"
+}
+
+// @public
+export const DriverErrorTypes: {
+    readonly genericNetworkError: "genericNetworkError";
+    readonly authorizationError: "authorizationError";
+    readonly fileNotFoundOrAccessDeniedError: "fileNotFoundOrAccessDeniedError";
+    readonly offlineError: "offlineError";
+    readonly unsupportedClientProtocolVersion: "unsupportedClientProtocolVersion";
+    readonly writeError: "writeError";
+    readonly fetchFailure: "fetchFailure";
+    readonly fetchTokenError: "fetchTokenError";
+    readonly incorrectServerResponse: "incorrectServerResponse";
+    readonly fileOverwrittenInStorage: "fileOverwrittenInStorage";
+    readonly deltaStreamConnectionForbidden: "deltaStreamConnectionForbidden";
+    readonly locationRedirection: "locationRedirection";
+    readonly fluidInvalidSchema: "fluidInvalidSchema";
+    readonly fileIsLocked: "fileIsLocked";
+    readonly outOfStorageError: "outOfStorageError";
+    readonly genericError: "genericError";
+    readonly throttlingError: "throttlingError";
+    readonly usageError: "usageError";
+};
+
+// @public (undocumented)
+export type DriverErrorTypes = (typeof DriverErrorTypes)[keyof typeof DriverErrorTypes];
+
+// @public
+export enum DriverHeader {
+    // (undocumented)
+    createNew = "createNew",
+    // (undocumented)
+    summarizingClient = "fluid-client-summarizer"
+}
+
+// @public
+export interface DriverPreCheckInfo {
+    codeDetailsHint?: string;
+    criticalBootDomains?: string[];
+}
+
+// @public (undocumented)
+export enum FetchSource {
+    // (undocumented)
+    default = "default",
+    // (undocumented)
+    noCache = "noCache"
+}
+
+// @public (undocumented)
+export type FiveDaysMs = 432000000;
+
+// @public
+export interface IAnyDriverError extends Omit<IDriverErrorBase, "errorType"> {
+    // (undocumented)
+    readonly errorType: string;
+}
+
+// @public (undocumented)
+export interface IAuthorizationError extends IDriverErrorBase {
+    // (undocumented)
+    readonly claims?: string;
+    // (undocumented)
+    readonly errorType: DriverErrorType.authorizationError;
+    // (undocumented)
+    readonly tenantId?: string;
+}
+
+// @public
+export interface IContainerPackageInfo {
+    name: string;
+}
+
+// @public (undocumented)
+export interface IDeltasFetchResult {
+    messages: ISequencedDocumentMessage[];
+    partialResult: boolean;
+}
+
+// @public
+export interface IDeltaStorageService {
+    get(tenantId: string, id: string, from: number, // inclusive
+    to: number, // exclusive
+    fetchReason?: string): Promise<IDeltasFetchResult>;
+}
+
+// @public (undocumented)
+export interface IDocumentDeltaConnection extends IDisposable, IEventProvider<IDocumentDeltaConnectionEvents> {
+    checkpointSequenceNumber?: number;
+    claims: ITokenClaims;
+    clientId: string;
+    existing: boolean;
+    initialClients: ISignalClient[];
+    initialMessages: ISequencedDocumentMessage[];
+    initialSignals: ISignalMessage[];
+    mode: ConnectionMode;
+    relayServiceAgent?: string;
+    serviceConfiguration: IClientConfiguration;
+    submit(messages: IDocumentMessage[]): void;
+    submitSignal(message: any): void;
+    version: string;
+}
+
+// @public (undocumented)
+export interface IDocumentDeltaConnectionEvents extends IErrorEvent {
+    // (undocumented)
+    (event: "nack", listener: (documentId: string, message: INack[]) => void): any;
+    // (undocumented)
+    (event: "disconnect", listener: (reason: IAnyDriverError) => void): any;
+    // (undocumented)
+    (event: "op", listener: (documentId: string, messages: ISequencedDocumentMessage[]) => void): any;
+    // (undocumented)
+    (event: "signal", listener: (message: ISignalMessage | ISignalMessage[]) => void): any;
+    // (undocumented)
+    (event: "pong", listener: (latency: number) => void): any;
+    // (undocumented)
+    (event: "error", listener: (error: any) => void): any;
+}
+
+// @public
+export interface IDocumentDeltaStorageService {
+    fetchMessages(from: number, to: number | undefined, abortSignal?: AbortSignal, cachedOnly?: boolean, fetchReason?: string): IStream<ISequencedDocumentMessage[]>;
+}
+
+// @public (undocumented)
+export interface IDocumentService {
+    connectToDeltaStorage(): Promise<IDocumentDeltaStorageService>;
+    connectToDeltaStream(client: IClient): Promise<IDocumentDeltaConnection>;
+    connectToStorage(): Promise<IDocumentStorageService>;
+    dispose(error?: any): void;
+    policies?: IDocumentServicePolicies;
+    // (undocumented)
+    resolvedUrl: IResolvedUrl;
+}
+
+// @public (undocumented)
+export interface IDocumentServiceFactory {
+    createContainer(createNewSummary: ISummaryTree | undefined, createNewResolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
+    createDocumentService(resolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
+}
+
+// @public (undocumented)
+export interface IDocumentServicePolicies {
+    readonly storageOnly?: boolean;
+    readonly summarizeProtocolTree?: boolean;
+}
+
+// @public
+export interface IDocumentStorageService extends Partial<IDisposable> {
+    createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse>;
+    downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree>;
+    getSnapshotTree(version?: IVersion, scenarioName?: string): Promise<ISnapshotTree | null>;
+    getVersions(versionId: string | null, count: number, scenarioName?: string, fetchSource?: FetchSource): Promise<IVersion[]>;
+    readonly policies?: IDocumentStorageServicePolicies;
+    readBlob(id: string): Promise<ArrayBufferLike>;
+    // (undocumented)
+    repositoryUrl: string;
+    uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string>;
+}
+
+// @public
+export interface IDocumentStorageServicePolicies {
+    readonly caching?: LoaderCachingPolicy;
+    readonly maximumCacheDurationMs?: FiveDaysMs;
+}
+
+// @public
+export interface IDriverBasicError extends IDriverErrorBase {
+    // (undocumented)
+    readonly errorType: DriverErrorType.genericError | DriverErrorType.fileNotFoundOrAccessDeniedError | DriverErrorType.offlineError | DriverErrorType.unsupportedClientProtocolVersion | DriverErrorType.writeError | DriverErrorType.fetchFailure | DriverErrorType.fetchTokenError | DriverErrorType.incorrectServerResponse | DriverErrorType.fileOverwrittenInStorage | DriverErrorType.fluidInvalidSchema | DriverErrorType.usageError | DriverErrorType.fileIsLocked | DriverErrorType.outOfStorageError;
+    // (undocumented)
+    readonly statusCode?: number;
+}
+
+// @public
+export interface IDriverErrorBase {
+    canRetry: boolean;
+    endpointReached?: boolean;
+    readonly errorType: DriverErrorType;
+    readonly message: string;
+    online?: string;
+}
+
+// @public (undocumented)
+export interface IDriverHeader {
+    // (undocumented)
+    [DriverHeader.summarizingClient]: boolean;
+    // (undocumented)
+    [DriverHeader.createNew]: any;
+}
+
+// @public (undocumented)
+export interface IGenericNetworkError extends IDriverErrorBase {
+    // (undocumented)
+    readonly errorType: DriverErrorType.genericNetworkError;
+    // (undocumented)
+    readonly statusCode?: number;
+}
+
+// @public (undocumented)
+export interface ILocationRedirectionError extends IDriverErrorBase {
+    // (undocumented)
+    readonly errorType: DriverErrorType.locationRedirection;
+    // (undocumented)
+    readonly redirectUrl: IResolvedUrl;
+}
+
+// @public (undocumented)
+export interface IResolvedUrl {
+    // (undocumented)
+    endpoints: {
+        [name: string]: string;
+    };
+    id: string;
+    // (undocumented)
+    tokens: {
+        [name: string]: string;
+    };
+    // (undocumented)
+    type: "fluid";
+    // (undocumented)
+    url: string;
+}
+
+// @public
+export interface IStream<T> {
+    // (undocumented)
+    read(): Promise<IStreamResult<T>>;
+}
+
+// @public (undocumented)
+export type IStreamResult<T> = {
+    done: true;
+} | {
+    done: false;
+    value: T;
+};
+
+// @public
+export interface ISummaryContext {
+    readonly ackHandle: string | undefined;
+    readonly proposalHandle: string | undefined;
+    // (undocumented)
+    readonly referenceSequenceNumber: number;
+}
+
+// @public (undocumented)
+export interface IThrottlingWarning extends IDriverErrorBase {
+    // (undocumented)
+    readonly errorType: DriverErrorType.throttlingError;
+    // (undocumented)
+    readonly retryAfterSeconds: number;
+}
+
+// @public (undocumented)
+export interface IUrlResolver {
+    getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string, packageInfoSource?: IContainerPackageInfo): Promise<string>;
+    // (undocumented)
+    resolve(request: IRequest): Promise<IResolvedUrl | undefined>;
+}
+
+// @public (undocumented)
+export enum LoaderCachingPolicy {
+    NoCaching = 0,
+    Prefetch = 1
+}
+
+// (No @packageDocumentation comment for this package)
+
+```