fluid-framework 2.63.0-359734 → 2.63.0

package/CHANGELOG.md

@@ -1,5 +1,86 @@
 # fluid-framework
 
+## 2.63.0
+
+### Minor Changes
+
+- Stabilize allowUnknownOptionalFields to beta [9b89d8f90f8](https://github.com/microsoft/FluidFramework/commit/9b89d8f90f8a4533d3cda786189421f48d6d4bab)
+
+  When constructing object node schema with `SchemaFactoryBeta.object` or `SchemaFactoryBeta.objectRecursive` you can now provide the `allowUnknownOptionalFields` option as well as other `metadata` which were previously only available in `SchemaFactoryAlpha.objectAlpha` and `SchemaFactoryAlpha.objectRecursive`.
+
+  Additionally the alpha interface `SchemaFactoryObjectOptions` has been renamed to `ObjectSchemaOptionsAlpha` to better align with the other related types.
+
+- Alpha APIs for annotated allowed types have been refactored [9b89d8f90f8](https://github.com/microsoft/FluidFramework/commit/9b89d8f90f8a4533d3cda786189421f48d6d4bab)
+
+  Staged allowed types must now be run through `SchemaFactoryAlpha.types` to convert them into an [`AllowedTypes`](https://fluidframework.com/docs/api/tree/allowedtypes-typealias).
+  This change also means that it is now possible to use the produced `AllowedTypesFull` in non-alpha APIs since it implements `AllowedTypes`.
+
+  Reading data out of `ImplicitAllowedTypes` should now be done via `normalizeAllowedTypes` which now returns a `AllowedTypesFull` providing access to all the data in a friendly format.
+
+- Add TreeBeta.create [9b89d8f90f8](https://github.com/microsoft/FluidFramework/commit/9b89d8f90f8a4533d3cda786189421f48d6d4bab)
+
+  Adds `TreeBeta.create`, which is a more stable version of the existing [`TreeAlpha.create`](https://fluidframework.com/docs/api/tree/treealpha-interface#create-methodsignature).
+  The only difference is the new `TreeBeta.create` does not support the `@alpha` [`UnsafeUnknownSchema`](https://fluidframework.com/docs/api/tree/unsafeunknownschema-typealias) option.
+
+- Add SchemaFactoryAlpha.typesRecursive and SchemaFactoryAlpha.stagedRecursive [9b89d8f90f8](https://github.com/microsoft/FluidFramework/commit/9b89d8f90f8a4533d3cda786189421f48d6d4bab)
+
+  With these new APIs, it is now possible to [`stage`](https://fluidframework.com/docs/api/fluid-framework/schemafactoryalpha-class#staged-property) changes to recursive types.
+
+- Add FluidSerializableAsTree domain for representing trees of serializable data (alpha) [9b89d8f90f8](https://github.com/microsoft/FluidFramework/commit/9b89d8f90f8a4533d3cda786189421f48d6d4bab)
+
+  Like [JsonAsTree](https://fluidframework.com/docs/api/tree/jsonastree-namespace/), but also supports [Fluid Handles](https://fluidframework.com/docs/concepts/handles).
+
+- Promote Record node types and factories to beta [9b89d8f90f8](https://github.com/microsoft/FluidFramework/commit/9b89d8f90f8a4533d3cda786189421f48d6d4bab)
+
+  Record tree node schema may now be declared using [SchemaFactoryBeta](https://fluidframework.com/docs/api/tree/schemafactorybeta-class) in addition to [SchemaFactoryAlpha](https://fluidframework.com/docs/api/tree/schemafactoryalpha-class).
+
+- Promote importConcise and exportConcise to beta [9b89d8f90f8](https://github.com/microsoft/FluidFramework/commit/9b89d8f90f8a4533d3cda786189421f48d6d4bab)
+
+  `importConcise` and `exportConcise` were previously available via [TreeAlpha](https://fluidframework.com/docs/api/tree/treealpha-interface).
+  They may now also be accessed via [TreeBeta](https://fluidframework.com/docs/api/tree/treebeta-interface).
+
+  Note that the beta form of `importConcise` does not support [UnsafeUnknownSchema](https://fluidframework.com/docs/api/fluid-framework/unsafeunknownschema-typealias).
+
+- MinimumVersionForCollab is now used in place of tree's alpha FluidClientVersion [9b89d8f90f8](https://github.com/microsoft/FluidFramework/commit/9b89d8f90f8a4533d3cda786189421f48d6d4bab)
+
+  `FluidClientVersion`: No longer used as the type for Fluid Client versions in APIs/codecs (for example, `oldestCompatibleClient`).
+  Additionally, `FluidClientVersion` is now a const object with members that declare specific [`MinimumVersionForCollab`](https://fluidframework.com/docs/api/runtime-definitions/minimumversionforcollab-typealias) versions.
+  These are intended to be used with APIs that require a version (such as `TreeAlpha.exportCompressed`).
+
+  `CodecWriteOptions` and `SharedTreeOptions`: `oldestCompatibleClient` has been replaced by `minVersionForCollab`.
+  See migration guide below.
+
+  `TreeAlpha.exportCompressed`: The `options` parameter previously had `oldestCompatibleClient` and now has `minVersionForCollab`.
+  Migrating requires a rename. Existing `FluidClientVersion.*` values are now `MinimumClientVersion`s.
+
+  #### Migrating
+
+  If an application is calling `loadContainerRuntime` directly and previously specified the minimum client version when
+  initializing Shared Tree like:
+
+  ```ts
+      const factory = configuredSharedTree({ ..., oldestCompatibleClient: FluidClientVersion.v2_52 });
+  ```
+
+  Then the new implementation depends on how the application initializes Fluid.
+
+  ##### Applications using `AzureClient`/`OdspClient`
+
+  If an application is using the declarative model (for example, `AzureClient`/`OdspClient`), it should continue to call `configuredSharedTree`
+  but specify `minVersionForCollab` instead:
+
+  ```ts
+      const factory = configuredSharedTree({ ..., minVersionForCollab: "2.52.0" });
+  ```
+
+  ##### Applications calling `loadContainerRuntime`
+
+  If an application is initializing the `ContainerRuntime` directly, it should now specify the `minVersionForCollab` there:
+
+  ```ts
+      const runtime = await loadContainerRuntime({ ..., minVersionForCollab: "2.52.0" });
+  ```
+
 ## 2.62.0
 
 ### Minor Changes

package/api-report/fluid-framework.alpha.api.md

@@ -33,6 +33,12 @@ export type AllowedTypesFullEvaluated = AllowedTypesFull<readonly AnnotatedAllow
 // @alpha @sealed
 export type AllowedTypesFullFromMixed<T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[]> = UnannotateAllowedTypesList<T> & AnnotatedAllowedTypes<AnnotateAllowedTypesList<T>>;
 
+// @alpha @sealed @system
+export type AllowedTypesFullFromMixedUnsafe<T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[]> = UnannotateAllowedTypesListUnsafe<T> & AnnotatedAllowedTypes<AnnotateAllowedTypesListUnsafe<T>>;
+
+// @alpha @sealed @system
+export type AllowedTypesFullUnsafe<T extends readonly AnnotatedAllowedTypeUnsafe[] = readonly AnnotatedAllowedTypeUnsafe[]> = AnnotatedAllowedTypes<T> & UnannotateAllowedTypesListUnsafe<T>;
+
 // @alpha @input
 export interface AllowedTypesMetadata {
     readonly custom?: unknown;
@@ -46,6 +52,11 @@ export type AnnotateAllowedTypesList<T extends readonly (AnnotatedAllowedType |
     [I in keyof T]: T[I] extends AnnotatedAllowedType<unknown> ? T[I] : AnnotatedAllowedType<T[I]>;
 };
 
+// @alpha @sealed @system
+export type AnnotateAllowedTypesListUnsafe<T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[]> = {
+    [I in keyof T]: T[I] extends AnnotatedAllowedTypeUnsafe ? T[I] : AnnotatedAllowedTypeUnsafe<T[I]>;
+};
+
 // @alpha @sealed
 export interface AnnotatedAllowedType<T = LazyItem<TreeNodeSchema>> {
     readonly metadata: AllowedTypeMetadata;
@@ -61,6 +72,14 @@ export interface AnnotatedAllowedTypes<T = readonly AnnotatedAllowedType[]> exte
     readonly types: T;
 }
 
+// @alpha @sealed @system
+export interface AnnotatedAllowedTypesUnsafe extends AnnotatedAllowedTypes<LazyItem<System_Unsafe.TreeNodeSchemaUnsafe>> {
+}
+
+// @alpha @sealed @system
+export interface AnnotatedAllowedTypeUnsafe<T = Unenforced<LazyItem<TreeNodeSchema>>> extends AnnotatedAllowedType<T> {
+}
+
 // @public @system
 type ApplyKind<T, Kind extends FieldKind> = {
     [FieldKind.Required]: T;
@@ -124,7 +143,7 @@ export function cloneWithReplacements(root: unknown, rootKey: string, replacer:
 
 // @alpha @input
 export interface CodecWriteOptions extends ICodecOptions {
-    readonly oldestCompatibleClient: FluidClientVersion;
+    readonly minVersionForCollab: MinimumVersionForCollab;
 }
 
 // @public
@@ -246,7 +265,7 @@ export function evaluateLazySchema<T extends TreeNodeSchema>(value: LazyItem<T>)
 type ExtractItemType<Item extends LazyItem> = Item extends () => infer Result ? Result : Item;
 
 // @alpha
-export function extractPersistedSchema(schema: ImplicitFieldSchema, oldestCompatibleClient: FluidClientVersion, includeStaged: (upgrade: SchemaUpgrade) => boolean): JsonCompatible;
+export function extractPersistedSchema(schema: ImplicitFieldSchema, minVersionForCollab: MinimumVersionForCollab, includeStaged: (upgrade: SchemaUpgrade) => boolean): JsonCompatible;
 
 // @alpha @system
 export type FactoryContent = IFluidHandle | string | number | boolean | null | Iterable<readonly [string, InsertableContent]> | readonly InsertableContent[] | FactoryContentObject;
@@ -331,11 +350,10 @@ type FlexList<Item = unknown> = readonly LazyItem<Item>[];
 type FlexListToUnion<TList extends FlexList> = ExtractItemType<TList[number]>;
 
 // @alpha
-export enum FluidClientVersion {
-    EnableUnstableFeatures,
-    v2_0 = 2,
-    v2_52 = 2.052
-}
+export const FluidClientVersion: {
+    readonly v2_0: "2.0.0";
+    readonly v2_52: "2.52.0";
+};
 
 // @public
 export type FluidObject<T = unknown> = {
@@ -1266,8 +1284,12 @@ export class SchemaFactoryAlpha<out TScope extends string | undefined = string |
     scopedFactoryAlpha<const T extends TName, TNameInner extends number | string = string>(name: T): SchemaFactoryAlpha<ScopedSchemaName<TScope, T>, TNameInner>;
     static staged: <const T extends LazyItem<TreeNodeSchema>>(t: T | AnnotatedAllowedType<T>) => AnnotatedAllowedType<T>;
     staged: <const T extends LazyItem<TreeNodeSchema>>(t: T | AnnotatedAllowedType<T>) => AnnotatedAllowedType<T>;
+    static stagedRecursive: <const T extends unknown>(t: T) => AnnotatedAllowedTypeUnsafe<UnannotateAllowedTypeUnsafe<T>>;
+    stagedRecursive: <const T extends unknown>(t: T) => AnnotatedAllowedTypeUnsafe<UnannotateAllowedTypeUnsafe<T>>;
     static types: <const T extends readonly (LazyItem<TreeNodeSchema> | AnnotatedAllowedType<LazyItem<TreeNodeSchema>>)[]>(t: T, metadata?: AllowedTypesMetadata | undefined) => AllowedTypesFullFromMixed<T>;
     types: <const T extends readonly (LazyItem<TreeNodeSchema> | AnnotatedAllowedType<LazyItem<TreeNodeSchema>>)[]>(t: T, metadata?: AllowedTypesMetadata | undefined) => AllowedTypesFullFromMixed<T>;
+    static typesRecursive: <const T extends readonly unknown[]>(t: T, metadata?: AllowedTypesMetadata | undefined) => AllowedTypesFullFromMixedUnsafe<T>;
+    typesRecursive: <const T extends readonly unknown[]>(t: T, metadata?: AllowedTypesMetadata | undefined) => AllowedTypesFullFromMixedUnsafe<T>;
 }
 
 // @beta
@@ -1306,7 +1328,9 @@ export interface SchemaStatics {
 // @alpha @sealed @system
 export interface SchemaStaticsAlpha {
     readonly staged: <const T extends LazyItem<TreeNodeSchema>>(t: T | AnnotatedAllowedType<T>) => AnnotatedAllowedType<T>;
+    stagedRecursive: <const T extends Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>>(t: T) => AnnotatedAllowedTypeUnsafe<UnannotateAllowedTypeUnsafe<T>>;
     readonly types: <const T extends readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[]>(t: T, metadata?: AllowedTypesMetadata) => AllowedTypesFullFromMixed<T>;
+    readonly typesRecursive: <const T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[]>(t: T, metadata?: AllowedTypesMetadata) => AllowedTypesFullFromMixedUnsafe<T>;
 }
 
 // @alpha @sealed
@@ -1714,7 +1738,7 @@ export interface TreeAlpha {
     create<const TSchema extends ImplicitFieldSchema | UnsafeUnknownSchema>(schema: UnsafeUnknownSchema extends TSchema ? ImplicitFieldSchema : TSchema & ImplicitFieldSchema, data: InsertableField<TSchema>): Unhydrated<TSchema extends ImplicitFieldSchema ? TreeFieldFromImplicitField<TSchema> : TreeNode | TreeLeafValue | undefined>;
     exportCompressed(tree: TreeNode | TreeLeafValue, options: {
         idCompressor?: IIdCompressor;
-    } & Pick<CodecWriteOptions, "oldestCompatibleClient">): JsonCompatible<IFluidHandle>;
+    } & Pick<CodecWriteOptions, "minVersionForCollab">): JsonCompatible<IFluidHandle>;
     exportConcise(node: TreeNode | TreeLeafValue, options?: TreeEncodingOptions): ConciseTree;
     exportConcise(node: TreeNode | TreeLeafValue | undefined, options?: TreeEncodingOptions): ConciseTree | undefined;
     exportVerbose(node: TreeNode | TreeLeafValue, options?: TreeEncodingOptions): VerboseTree;
@@ -2007,6 +2031,16 @@ export type UnannotateAllowedTypesList<T extends readonly (AnnotatedAllowedType
     [I in keyof T]: T[I] extends AnnotatedAllowedType<infer X> ? X : T[I];
 };
 
+// @alpha @sealed @system
+export type UnannotateAllowedTypesListUnsafe<T extends readonly Unenforced<AnnotatedAllowedType | LazyItem<TreeNodeSchema>>[]> = {
+    readonly [I in keyof T]: T[I] extends {
+        type: infer X;
+    } ? X : T[I];
+};
+
+// @alpha @sealed @system
+export type UnannotateAllowedTypeUnsafe<T extends Unenforced<AnnotatedAllowedTypeUnsafe | LazyItem<System_Unsafe.TreeNodeSchemaUnsafe>>> = T extends AnnotatedAllowedTypeUnsafe<infer X> ? X : T;
+
 // @public
 export type Unenforced<_DesiredExtendsConstraint> = unknown;
 

package/dist/alpha.d.ts

@@ -167,10 +167,15 @@ export {
 	AllowedTypesFull, 
 	AllowedTypesFullEvaluated, 
 	AllowedTypesFullFromMixed, 
+	AllowedTypesFullFromMixedUnsafe, 
+	AllowedTypesFullUnsafe, 
 	AllowedTypesMetadata, 
 	AnnotateAllowedTypesList, 
+	AnnotateAllowedTypesListUnsafe, 
 	AnnotatedAllowedType, 
+	AnnotatedAllowedTypeUnsafe, 
 	AnnotatedAllowedTypes, 
+	AnnotatedAllowedTypesUnsafe, 
 	ArrayNodeCustomizableSchema, 
 	ArrayNodeCustomizableSchemaUnsafe, 
 	ArrayNodePojoEmulationSchema, 
@@ -272,7 +277,9 @@ export {
 	TreeSchemaEncodingOptions, 
 	TreeViewAlpha, 
 	TreeViewConfigurationAlpha, 
+	UnannotateAllowedTypeUnsafe, 
 	UnannotateAllowedTypesList, 
+	UnannotateAllowedTypesListUnsafe, 
 	UnsafeUnknownSchema, 
 	ValueSchema, 
 	VerboseTree, 

package/lib/alpha.d.ts

@@ -167,10 +167,15 @@ export {
 	AllowedTypesFull, 
 	AllowedTypesFullEvaluated, 
 	AllowedTypesFullFromMixed, 
+	AllowedTypesFullFromMixedUnsafe, 
+	AllowedTypesFullUnsafe, 
 	AllowedTypesMetadata, 
 	AnnotateAllowedTypesList, 
+	AnnotateAllowedTypesListUnsafe, 
 	AnnotatedAllowedType, 
+	AnnotatedAllowedTypeUnsafe, 
 	AnnotatedAllowedTypes, 
+	AnnotatedAllowedTypesUnsafe, 
 	ArrayNodeCustomizableSchema, 
 	ArrayNodeCustomizableSchemaUnsafe, 
 	ArrayNodePojoEmulationSchema, 
@@ -272,7 +277,9 @@ export {
 	TreeSchemaEncodingOptions, 
 	TreeViewAlpha, 
 	TreeViewConfigurationAlpha, 
+	UnannotateAllowedTypeUnsafe, 
 	UnannotateAllowedTypesList, 
+	UnannotateAllowedTypesListUnsafe, 
 	UnsafeUnknownSchema, 
 	ValueSchema, 
 	VerboseTree, 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluid-framework",
-  "version": "2.63.0-359734",
+  "version": "2.63.0",
   "description": "The main entry point into Fluid Framework public packages",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -57,17 +57,17 @@
   "main": "lib/index.js",
   "types": "lib/public.d.ts",
   "dependencies": {
-    "@fluidframework/container-definitions": "2.63.0-359734",
-    "@fluidframework/container-loader": "2.63.0-359734",
-    "@fluidframework/core-interfaces": "2.63.0-359734",
-    "@fluidframework/core-utils": "2.63.0-359734",
-    "@fluidframework/driver-definitions": "2.63.0-359734",
-    "@fluidframework/fluid-static": "2.63.0-359734",
-    "@fluidframework/map": "2.63.0-359734",
-    "@fluidframework/runtime-utils": "2.63.0-359734",
-    "@fluidframework/sequence": "2.63.0-359734",
-    "@fluidframework/shared-object-base": "2.63.0-359734",
-    "@fluidframework/tree": "2.63.0-359734"
+    "@fluidframework/container-definitions": "~2.63.0",
+    "@fluidframework/container-loader": "~2.63.0",
+    "@fluidframework/core-interfaces": "~2.63.0",
+    "@fluidframework/core-utils": "~2.63.0",
+    "@fluidframework/driver-definitions": "~2.63.0",
+    "@fluidframework/fluid-static": "~2.63.0",
+    "@fluidframework/map": "~2.63.0",
+    "@fluidframework/runtime-utils": "~2.63.0",
+    "@fluidframework/sequence": "~2.63.0",
+    "@fluidframework/shared-object-base": "~2.63.0",
+    "@fluidframework/tree": "~2.63.0"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.17.1",