@fluidframework/tree 2.51.0 → 2.52.0

package/dist/simple-tree/api/discrepancies.d.ts

@@ -0,0 +1,98 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { type FieldKey, type FieldKindIdentifier, LeafNodeStoredSchema, MapNodeStoredSchema, ObjectNodeStoredSchema, type TreeNodeSchemaIdentifier, type TreeStoredSchema, type TreeTypeSet, type ValueSchema } from "../../core/index.js";
+import { NodeKind, type AnnotatedAllowedType, type TreeNodeSchema } from "../core/index.js";
+import type { TreeSchema } from "./configuration.js";
+/**
+ * Discriminated union (keyed on `mismatch`) of discrepancies between a view and stored schema which
+ * make it possible for content matching the stored schema to be incompatible with the view schema.
+ */
+export type Discrepancy = FieldDiscrepancy | NodeKindDiscrepancy;
+/**
+ * A discrepancy in the declaration of a field.
+ */
+export type FieldDiscrepancy = AllowedTypeDiscrepancy | FieldKindDiscrepancy | ValueSchemaDiscrepancy;
+/**
+ * Information about where a field discrepancy is located within a collection of schema.
+ */
+export interface FieldDiscrepancyLocation {
+    /**
+     * The {@link TreeNodeSchemaIdentifier} that contains the discrepancy.
+     *
+     * Undefined iff the discrepancy is part of the root field schema.
+     */
+    readonly identifier: TreeNodeSchemaIdentifier | undefined;
+    /**
+     * The {@link FieldKey} for the field that contains the discrepancy.
+     * Undefined when:
+     * - the discrepancy is part of the root field schema
+     * - the discrepancy is for 'all fields' of a map node
+     */
+    readonly fieldKey: FieldKey | undefined;
+}
+/**
+ * A discrepancy in the allowed types of a field.
+ *
+ * @remarks
+ * This reports the symmetric difference of allowed types.
+ */
+export interface AllowedTypeDiscrepancy extends FieldDiscrepancyLocation {
+    readonly mismatch: "allowedTypes";
+    /**
+     * List of annotated allowed types in viewed schema which are not allowed in stored schema
+     */
+    readonly view: readonly AnnotatedAllowedType<TreeNodeSchema>[];
+    /**
+     * List of allowed type identifiers in stored schema which are not allowed in view schema
+     */
+    readonly stored: readonly TreeNodeSchemaIdentifier[];
+}
+/**
+ * Differences in `FieldKindIdentifier` between two schema.
+ */
+export interface FieldKindDiscrepancy extends FieldDiscrepancyLocation {
+    readonly mismatch: "fieldKind";
+    readonly view: FieldKindIdentifier;
+    readonly stored: FieldKindIdentifier;
+}
+/**
+ * Differences in the `ValueSchema` of two `LeafNodeStoredSchema` objects.
+ */
+export interface ValueSchemaDiscrepancy {
+    identifier: TreeNodeSchemaIdentifier;
+    mismatch: "valueSchema";
+    view: ValueSchema | undefined;
+    stored: ValueSchema | undefined;
+}
+/**
+ * Differences in the kind of node schema.
+ *
+ * Includes when stored object schema are expected to be compatible with an array node schema.
+ */
+export interface NodeKindDiscrepancy {
+    identifier: TreeNodeSchemaIdentifier;
+    mismatch: "nodeKind";
+    view: NodeKind;
+    stored: SchemaFactoryNodeKind;
+}
+type SchemaFactoryNodeKind = typeof ObjectNodeStoredSchema | typeof MapNodeStoredSchema | typeof LeafNodeStoredSchema;
+/**
+ * Finds and reports discrepancies between a view schema and a stored schema which make "canView" false.
+ * @remarks
+ * See documentation on {@link Discrepancy} and its subtypes for details of possible discrepancies.
+ */
+export declare function getDiscrepanciesInAllowedContent(view: TreeSchema, stored: TreeStoredSchema): Iterable<Discrepancy>;
+/**
+ * Returns the allowed types that are not present in both the given view and stored schemas.
+ * It returns a tuple containing two arrays:
+ * 1. The first array contains the allowed types that are present in the view schema but not in the stored schema.
+ * 2. The second array contains the allowed types that are present in the stored schema but not in the view schema.
+ */
+export declare function findExtraAllowedTypes(viewAllowedTypes: readonly AnnotatedAllowedType<TreeNodeSchema>[], storedAllowedTypes: TreeTypeSet): {
+    viewExtra: readonly AnnotatedAllowedType<TreeNodeSchema>[];
+    storedExtra: TreeNodeSchemaIdentifier[];
+};
+export {};
+//# sourceMappingURL=discrepancies.d.ts.map

package/dist/simple-tree/api/discrepancies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discrepancies.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/discrepancies.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAEN,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAExB,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EAGtB,KAAK,wBAAwB,EAE7B,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACN,QAAQ,EAER,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,MAAM,kBAAkB,CAAC;AAgB1B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAIrD;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACzB,sBAAsB,GACtB,oBAAoB,GACpB,sBAAsB,CAAC;AAE1B;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,wBAAwB,GAAG,SAAS,CAAC;IAC1D;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAuB,SAAQ,wBAAwB;IACvE,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,oBAAoB,CAAC,cAAc,CAAC,EAAE,CAAC;IAC/D;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,wBAAwB,EAAE,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,wBAAwB;IACrE,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,UAAU,EAAE,wBAAwB,CAAC;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,WAAW,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC,UAAU,EAAE,wBAAwB,CAAC;IACrC,QAAQ,EAAE,UAAU,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,qBAAqB,CAAC;CAC9B;AAED,KAAK,qBAAqB,GACvB,OAAO,sBAAsB,GAC7B,OAAO,mBAAmB,GAC1B,OAAO,oBAAoB,CAAC;AAiC/B;;;;GAIG;AACH,wBAAiB,gCAAgC,CAChD,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,gBAAgB,GACtB,QAAQ,CAAC,WAAW,CAAC,CAcvB;AA2GD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACpC,gBAAgB,EAAE,SAAS,oBAAoB,CAAC,cAAc,CAAC,EAAE,EACjE,kBAAkB,EAAE,WAAW,GAC7B;IACF,SAAS,EAAE,SAAS,oBAAoB,CAAC,cAAc,CAAC,EAAE,CAAC;IAC3D,WAAW,EAAE,wBAAwB,EAAE,CAAC;CACxC,CAYA"}

package/dist/simple-tree/api/discrepancies.js

@@ -0,0 +1,255 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findExtraAllowedTypes = exports.getDiscrepanciesInAllowedContent = void 0;
+const internal_1 = require("@fluidframework/core-utils/internal");
+const index_js_1 = require("../../core/index.js");
+const index_js_2 = require("../../util/index.js");
+const index_js_3 = require("../core/index.js");
+const index_js_4 = require("../node-kinds/index.js");
+const toStoredSchema_js_1 = require("../toStoredSchema.js");
+const fieldSchema_js_1 = require("../fieldSchema.js");
+const leafNodeSchema_js_1 = require("../leafNodeSchema.js");
+const customTree_js_1 = require("./customTree.js");
+const index_js_5 = require("../../feature-libraries/index.js");
+function getStoredNodeSchemaType(nodeSchema) {
+    if (nodeSchema instanceof index_js_1.ObjectNodeStoredSchema) {
+        return index_js_1.ObjectNodeStoredSchema;
+    }
+    if (nodeSchema instanceof index_js_1.MapNodeStoredSchema) {
+        return index_js_1.MapNodeStoredSchema;
+    }
+    if (nodeSchema instanceof index_js_1.LeafNodeStoredSchema) {
+        return index_js_1.LeafNodeStoredSchema;
+    }
+    (0, internal_1.fail)(0xbe8 /* Invalid stored node schema type */);
+}
+function doesNodeKindMatchStoredNodeKind(viewKind, storedType) {
+    switch (viewKind) {
+        case index_js_3.NodeKind.Leaf:
+            return storedType === index_js_1.LeafNodeStoredSchema;
+        case index_js_3.NodeKind.Array:
+        case index_js_3.NodeKind.Object:
+            return storedType === index_js_1.ObjectNodeStoredSchema;
+        case index_js_3.NodeKind.Map:
+        case index_js_3.NodeKind.Record:
+            return storedType === index_js_1.MapNodeStoredSchema;
+        default:
+            (0, internal_1.unreachableCase)(viewKind);
+    }
+}
+/**
+ * Finds and reports discrepancies between a view schema and a stored schema which make "canView" false.
+ * @remarks
+ * See documentation on {@link Discrepancy} and its subtypes for details of possible discrepancies.
+ */
+function* getDiscrepanciesInAllowedContent(view, stored) {
+    // check root field discrepancies
+    yield* getFieldDiscrepancies(view.root, stored.rootFieldSchema, undefined, undefined);
+    // Check all of the stored nodes, including their fields for discrepancies.
+    for (const [identifier, storedSchema] of stored.nodeSchema) {
+        const viewSchema = view.definitions.get(identifier);
+        // if the view schema has a node that's also in the stored schema, check it.
+        if (viewSchema !== undefined) {
+            yield* getNodeDiscrepancies(identifier, viewSchema, storedSchema);
+        }
+        // Note that nodes that are missing in the view schema are only a problem if other stored schema nodes actually reference them which will produce its own discrepancy, so we can rely on that to produce any needed discrepancies.
+    }
+}
+exports.getDiscrepanciesInAllowedContent = getDiscrepanciesInAllowedContent;
+function* getNodeDiscrepancies(identifier, view, stored) {
+    if (!doesNodeKindMatchStoredNodeKind(view.kind, getStoredNodeSchemaType(stored))) {
+        yield {
+            identifier,
+            mismatch: "nodeKind",
+            view: view.kind,
+            stored: getStoredNodeSchemaType(stored),
+        };
+        return;
+    }
+    switch (view.kind) {
+        case index_js_3.NodeKind.Object: {
+            (0, internal_1.assert)((0, index_js_4.isObjectNodeSchema)(view), 0xbe9 /* schema with node kind of object must implement ObjectNodeSchema */);
+            yield* computeObjectNodeDiscrepancies(identifier, view, stored);
+            break;
+        }
+        case index_js_3.NodeKind.Array: {
+            (0, internal_1.assert)((0, index_js_4.isArrayNodeSchema)(view), 0xbea /* schema with node kind of array must implement ArrayNodeSchema */);
+            const arrayStoredSchema = (0, customTree_js_1.tryStoredSchemaAsArray)(stored);
+            if (arrayStoredSchema === undefined) {
+                yield {
+                    identifier,
+                    mismatch: "nodeKind",
+                    view: index_js_3.NodeKind.Array,
+                    stored: getStoredNodeSchemaType(stored),
+                };
+                return;
+            }
+            yield* getAllowedTypeDiscrepancies((0, index_js_3.normalizeAnnotatedAllowedTypes)(view.info).types, arrayStoredSchema, (0, index_js_2.brand)(view.identifier), index_js_1.EmptyKey);
+            break;
+        }
+        case index_js_3.NodeKind.Map: {
+            (0, internal_1.assert)((0, index_js_4.isMapNodeSchema)(view), 0xbeb /* schema with node kind of map must implement MapNodeSchema */);
+            yield* getFieldDiscrepancies((0, fieldSchema_js_1.createFieldSchema)(fieldSchema_js_1.FieldKind.Optional, view.info), stored.mapFields, identifier, undefined);
+            break;
+        }
+        case index_js_3.NodeKind.Record: {
+            (0, internal_1.assert)((0, index_js_4.isRecordNodeSchema)(view), 0xbec /* schema with node kind of record must implement RecordNodeSchema */);
+            yield* getFieldDiscrepancies((0, fieldSchema_js_1.createFieldSchema)(fieldSchema_js_1.FieldKind.Optional, view.info), stored.mapFields, identifier, undefined);
+            break;
+        }
+        case index_js_3.NodeKind.Leaf: {
+            (0, internal_1.assert)(view instanceof leafNodeSchema_js_1.LeafNodeSchema, 0xbed /* schema with node kind of leaf must implement LeafNodeSchema */);
+            // TODO: leafKind seems like a bad name
+            const viewValue = view.leafKind;
+            const storedValue = stored.leafValue;
+            if (viewValue !== storedValue) {
+                yield {
+                    identifier,
+                    mismatch: "valueSchema",
+                    view: viewValue,
+                    stored: storedValue,
+                };
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+/**
+ * Returns the allowed types that are not present in both the given view and stored schemas.
+ * It returns a tuple containing two arrays:
+ * 1. The first array contains the allowed types that are present in the view schema but not in the stored schema.
+ * 2. The second array contains the allowed types that are present in the stored schema but not in the view schema.
+ */
+function findExtraAllowedTypes(viewAllowedTypes, storedAllowedTypes) {
+    const viewNodeSchemaIdentifiers = new Set(viewAllowedTypes.map((value) => value.type.identifier));
+    const viewExtra = viewAllowedTypes.filter((value) => !storedAllowedTypes.has((0, index_js_2.brand)(value.type.identifier)));
+    const storedExtra = [...storedAllowedTypes].filter((value) => !viewNodeSchemaIdentifiers.has(value));
+    return { viewExtra, storedExtra };
+}
+exports.findExtraAllowedTypes = findExtraAllowedTypes;
+/**
+ * The function to track the discrepancies between a field view schema and a stored schema.
+ *
+ * @remarks
+ * This function yields discrepancies in the following cases:
+ * 1. If the view schema has allowed types that are not present in the stored schema.
+ * 2. If the stored schema has allowed types that are not present in the view schema.
+ * 3. If the field kind in the view schema is not compatible with the stored schema.
+ *
+ * This function does not recurse into the nodes of the view schema and only makes comparisons at the field level.
+ *
+ * @param fieldKey - If the key is missing, it indicates that this is the root field schema.
+ */
+function* getFieldDiscrepancies(view, stored, identifier, fieldKey) {
+    (0, internal_1.assert)(view instanceof fieldSchema_js_1.FieldSchemaAlpha, 0xbee /* all field schema should be FieldSchemaAlpha */);
+    yield* getAllowedTypeDiscrepancies(view.annotatedAllowedTypesNormalized.types, stored.types, identifier, fieldKey);
+    const viewKind = toStoredSchema_js_1.convertFieldKind.get(view.kind) ??
+        (0, internal_1.fail)(0xbef /* A conversion from a FieldKind to a FlexFieldKind should exist */);
+    // This checks if the field kind in the view schema is not compatible with the stored schema.
+    if (viewKind.identifier !== stored.kind) {
+        yield {
+            identifier,
+            fieldKey,
+            mismatch: "fieldKind",
+            view: viewKind.identifier,
+            stored: stored.kind,
+        };
+    }
+}
+/**
+ * The function to track the discrepancies between a field view schema and a stored schema.
+ *
+ * @remarks
+ * This function yields discrepancies in the following cases:
+ * 1. If the view schema has allowed types that are not present in the stored schema.
+ * 2. If the stored schema has allowed types that are not present in the view schema.
+ *
+ * This function does not recurse into the nodes of the view schema and only makes comparisons at the field level.
+ *
+ * @param fieldKey - If the key is missing, it indicates that this is the root field schema.
+ */
+function* getAllowedTypeDiscrepancies(view, stored, identifier, fieldKey) {
+    const { viewExtra, storedExtra } = findExtraAllowedTypes(view, stored);
+    if (viewExtra.length > 0 || storedExtra.length > 0) {
+        yield {
+            identifier,
+            fieldKey,
+            mismatch: "allowedTypes",
+            view: viewExtra,
+            stored: storedExtra,
+        };
+    }
+}
+/**
+ * Computes discrepancies between a view schema and a stored schema for nodes that are treated as object nodes in the stored schema.
+ * This includes both view object nodes and view array nodes.
+ *
+ * This function yields discrepancies in the following cases:
+ *
+ * 1. If the view schema has fields that are not present in the stored schema.
+ * 2. If the stored schema has fields that are not present in the view schema.
+ * 3. If the field kind or allowed types of a field in the view schema is not compatible with the stored schema.
+ *
+ * This function includes discrepancies within the common fields and their allowed types, but does NOT recurse to report and discrepancies within the node types referenced by those fields.
+ */
+function* computeObjectNodeDiscrepancies(identifier, view, stored) {
+    /**
+     * Similar to the logic used for tracking discrepancies between two node schemas, we will identify
+     * three types of differences:
+     * 1. Fields that exist in the view schema but not in the stored schema.
+     * 2. Fields that exist in both schemas but have different contents.
+     * 3. Fields that exist in the stored schema but not in the view schema.
+     *
+     * First, the view schema is iterated to track the first two types of differences.
+     * Then, the stored schema is iterated to find the third type.
+     */
+    const viewKeys = new Set();
+    for (const [_, { storedKey: fieldKey, schema: fieldSchema }] of view.flexKeyMap) {
+        const storedSchema = stored.objectNodeFields.get(fieldKey);
+        viewKeys.add(fieldKey);
+        // If the view schema has a field that's not in the stored schema
+        if (storedSchema === undefined) {
+            const viewKind = toStoredSchema_js_1.convertFieldKind.get(fieldSchema.kind) ??
+                (0, internal_1.fail)(0xbf0 /* A conversion from a FieldKind to a FlexFieldKind should exist */);
+            yield {
+                identifier,
+                fieldKey,
+                mismatch: "fieldKind",
+                view: viewKind.identifier,
+                stored: index_js_1.storedEmptyFieldSchema.kind,
+            };
+        }
+        else {
+            yield* getFieldDiscrepancies(fieldSchema, storedSchema, identifier, fieldKey);
+        }
+    }
+    for (const [fieldKey, schema] of stored.objectNodeFields) {
+        if (schema.kind === index_js_1.forbiddenFieldKindIdentifier) {
+            // In the stored schema the field is explicitly forbidden.
+            // This has the same semantics of the field not being mentioned in the stored schema,
+            // and thus can be skipped.
+            continue;
+        }
+        // If the stored schema has a field that's not in the view schema
+        if (!viewKeys.has(fieldKey)) {
+            // When the application has opted into it, we allow viewing documents which have additional
+            // optional fields in the stored schema that are not present in the view schema.
+            if (!view.allowUnknownOptionalFields || schema.kind !== index_js_5.FieldKinds.optional.identifier) {
+                yield {
+                    identifier,
+                    fieldKey,
+                    mismatch: "fieldKind",
+                    view: index_js_1.storedEmptyFieldSchema.kind,
+                    stored: schema.kind,
+                };
+            }
+        }
+    }
+}
+//# sourceMappingURL=discrepancies.js.map

package/dist/simple-tree/api/discrepancies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discrepancies.js","sourceRoot":"","sources":["../../../src/simple-tree/api/discrepancies.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert, fail, unreachableCase } from \"@fluidframework/core-utils/internal\";\n\nimport {\n\tEmptyKey,\n\ttype FieldKey,\n\ttype FieldKindIdentifier,\n\tforbiddenFieldKindIdentifier,\n\tLeafNodeStoredSchema,\n\tMapNodeStoredSchema,\n\tObjectNodeStoredSchema,\n\tstoredEmptyFieldSchema,\n\ttype TreeFieldStoredSchema,\n\ttype TreeNodeSchemaIdentifier,\n\ttype TreeNodeStoredSchema,\n\ttype TreeStoredSchema,\n\ttype TreeTypeSet,\n\ttype ValueSchema,\n} from \"../../core/index.js\";\nimport { brand } from \"../../util/index.js\";\nimport {\n\tNodeKind,\n\tnormalizeAnnotatedAllowedTypes,\n\ttype AnnotatedAllowedType,\n\ttype TreeNodeSchema,\n} from \"../core/index.js\";\nimport {\n\tisArrayNodeSchema,\n\tisMapNodeSchema,\n\tisObjectNodeSchema,\n\tisRecordNodeSchema,\n\ttype ObjectNodeSchemaPrivate,\n} from \"../node-kinds/index.js\";\nimport { convertFieldKind } from \"../toStoredSchema.js\";\nimport {\n\tcreateFieldSchema,\n\tFieldKind,\n\tFieldSchemaAlpha,\n\ttype FieldSchema,\n} from \"../fieldSchema.js\";\nimport { LeafNodeSchema } from \"../leafNodeSchema.js\";\nimport type { TreeSchema } from \"./configuration.js\";\nimport { tryStoredSchemaAsArray } from \"./customTree.js\";\nimport { FieldKinds } from \"../../feature-libraries/index.js\";\n\n/**\n * Discriminated union (keyed on `mismatch`) of discrepancies between a view and stored schema which\n * make it possible for content matching the stored schema to be incompatible with the view schema.\n */\nexport type Discrepancy = FieldDiscrepancy | NodeKindDiscrepancy;\n\n/**\n * A discrepancy in the declaration of a field.\n */\nexport type FieldDiscrepancy =\n\t| AllowedTypeDiscrepancy\n\t| FieldKindDiscrepancy\n\t| ValueSchemaDiscrepancy;\n\n/**\n * Information about where a field discrepancy is located within a collection of schema.\n */\nexport interface FieldDiscrepancyLocation {\n\t/**\n\t * The {@link TreeNodeSchemaIdentifier} that contains the discrepancy.\n\t *\n\t * Undefined iff the discrepancy is part of the root field schema.\n\t */\n\treadonly identifier: TreeNodeSchemaIdentifier | undefined;\n\t/**\n\t * The {@link FieldKey} for the field that contains the discrepancy.\n\t * Undefined when:\n\t * - the discrepancy is part of the root field schema\n\t * - the discrepancy is for 'all fields' of a map node\n\t */\n\treadonly fieldKey: FieldKey | undefined;\n}\n\n/**\n * A discrepancy in the allowed types of a field.\n *\n * @remarks\n * This reports the symmetric difference of allowed types.\n */\nexport interface AllowedTypeDiscrepancy extends FieldDiscrepancyLocation {\n\treadonly mismatch: \"allowedTypes\";\n\t/**\n\t * List of annotated allowed types in viewed schema which are not allowed in stored schema\n\t */\n\treadonly view: readonly AnnotatedAllowedType<TreeNodeSchema>[];\n\t/**\n\t * List of allowed type identifiers in stored schema which are not allowed in view schema\n\t */\n\treadonly stored: readonly TreeNodeSchemaIdentifier[];\n}\n\n/**\n * Differences in `FieldKindIdentifier` between two schema.\n */\nexport interface FieldKindDiscrepancy extends FieldDiscrepancyLocation {\n\treadonly mismatch: \"fieldKind\";\n\treadonly view: FieldKindIdentifier;\n\treadonly stored: FieldKindIdentifier;\n}\n\n/**\n * Differences in the `ValueSchema` of two `LeafNodeStoredSchema` objects.\n */\nexport interface ValueSchemaDiscrepancy {\n\tidentifier: TreeNodeSchemaIdentifier;\n\tmismatch: \"valueSchema\";\n\tview: ValueSchema | undefined;\n\tstored: ValueSchema | undefined;\n}\n\n/**\n * Differences in the kind of node schema.\n *\n * Includes when stored object schema are expected to be compatible with an array node schema.\n */\nexport interface NodeKindDiscrepancy {\n\tidentifier: TreeNodeSchemaIdentifier;\n\tmismatch: \"nodeKind\";\n\tview: NodeKind;\n\tstored: SchemaFactoryNodeKind;\n}\n\ntype SchemaFactoryNodeKind =\n\t| typeof ObjectNodeStoredSchema\n\t| typeof MapNodeStoredSchema\n\t| typeof LeafNodeStoredSchema;\n\nfunction getStoredNodeSchemaType(nodeSchema: TreeNodeStoredSchema): SchemaFactoryNodeKind {\n\tif (nodeSchema instanceof ObjectNodeStoredSchema) {\n\t\treturn ObjectNodeStoredSchema;\n\t}\n\tif (nodeSchema instanceof MapNodeStoredSchema) {\n\t\treturn MapNodeStoredSchema;\n\t}\n\tif (nodeSchema instanceof LeafNodeStoredSchema) {\n\t\treturn LeafNodeStoredSchema;\n\t}\n\tfail(0xbe8 /* Invalid stored node schema type */);\n}\n\nfunction doesNodeKindMatchStoredNodeKind(\n\tviewKind: NodeKind,\n\tstoredType: SchemaFactoryNodeKind,\n): boolean {\n\tswitch (viewKind) {\n\t\tcase NodeKind.Leaf:\n\t\t\treturn storedType === LeafNodeStoredSchema;\n\t\tcase NodeKind.Array:\n\t\tcase NodeKind.Object:\n\t\t\treturn storedType === ObjectNodeStoredSchema;\n\t\tcase NodeKind.Map:\n\t\tcase NodeKind.Record:\n\t\t\treturn storedType === MapNodeStoredSchema;\n\t\tdefault:\n\t\t\tunreachableCase(viewKind);\n\t}\n}\n\n/**\n * Finds and reports discrepancies between a view schema and a stored schema which make \"canView\" false.\n * @remarks\n * See documentation on {@link Discrepancy} and its subtypes for details of possible discrepancies.\n */\nexport function* getDiscrepanciesInAllowedContent(\n\tview: TreeSchema,\n\tstored: TreeStoredSchema,\n): Iterable<Discrepancy> {\n\t// check root field discrepancies\n\tyield* getFieldDiscrepancies(view.root, stored.rootFieldSchema, undefined, undefined);\n\n\t// Check all of the stored nodes, including their fields for discrepancies.\n\tfor (const [identifier, storedSchema] of stored.nodeSchema) {\n\t\tconst viewSchema = view.definitions.get(identifier);\n\n\t\t// if the view schema has a node that's also in the stored schema, check it.\n\t\tif (viewSchema !== undefined) {\n\t\t\tyield* getNodeDiscrepancies(identifier, viewSchema, storedSchema);\n\t\t}\n\t\t// Note that nodes that are missing in the view schema are only a problem if other stored schema nodes actually reference them which will produce its own discrepancy, so we can rely on that to produce any needed discrepancies.\n\t}\n}\n\nfunction* getNodeDiscrepancies(\n\tidentifier: TreeNodeSchemaIdentifier,\n\tview: TreeNodeSchema,\n\tstored: TreeNodeStoredSchema,\n): Iterable<Discrepancy> {\n\tif (!doesNodeKindMatchStoredNodeKind(view.kind, getStoredNodeSchemaType(stored))) {\n\t\tyield {\n\t\t\tidentifier,\n\t\t\tmismatch: \"nodeKind\",\n\t\t\tview: view.kind,\n\t\t\tstored: getStoredNodeSchemaType(stored),\n\t\t};\n\t\treturn;\n\t}\n\n\tswitch (view.kind) {\n\t\tcase NodeKind.Object: {\n\t\t\tassert(\n\t\t\t\tisObjectNodeSchema(view),\n\t\t\t\t0xbe9 /* schema with node kind of object must implement ObjectNodeSchema */,\n\t\t\t);\n\t\t\tyield* computeObjectNodeDiscrepancies(\n\t\t\t\tidentifier,\n\t\t\t\tview,\n\t\t\t\tstored as ObjectNodeStoredSchema,\n\t\t\t);\n\t\t\tbreak;\n\t\t}\n\t\tcase NodeKind.Array: {\n\t\t\tassert(\n\t\t\t\tisArrayNodeSchema(view),\n\t\t\t\t0xbea /* schema with node kind of array must implement ArrayNodeSchema */,\n\t\t\t);\n\n\t\t\tconst arrayStoredSchema = tryStoredSchemaAsArray(stored);\n\t\t\tif (arrayStoredSchema === undefined) {\n\t\t\t\tyield {\n\t\t\t\t\tidentifier,\n\t\t\t\t\tmismatch: \"nodeKind\",\n\t\t\t\t\tview: NodeKind.Array,\n\t\t\t\t\tstored: getStoredNodeSchemaType(stored),\n\t\t\t\t};\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tyield* getAllowedTypeDiscrepancies(\n\t\t\t\tnormalizeAnnotatedAllowedTypes(view.info).types,\n\t\t\t\tarrayStoredSchema,\n\t\t\t\tbrand(view.identifier),\n\t\t\t\tEmptyKey,\n\t\t\t);\n\n\t\t\tbreak;\n\t\t}\n\t\tcase NodeKind.Map: {\n\t\t\tassert(\n\t\t\t\tisMapNodeSchema(view),\n\t\t\t\t0xbeb /* schema with node kind of map must implement MapNodeSchema */,\n\t\t\t);\n\n\t\t\tyield* getFieldDiscrepancies(\n\t\t\t\tcreateFieldSchema(FieldKind.Optional, view.info),\n\t\t\t\t(stored as MapNodeStoredSchema).mapFields,\n\t\t\t\tidentifier,\n\t\t\t\tundefined,\n\t\t\t);\n\t\t\tbreak;\n\t\t}\n\t\tcase NodeKind.Record: {\n\t\t\tassert(\n\t\t\t\tisRecordNodeSchema(view),\n\t\t\t\t0xbec /* schema with node kind of record must implement RecordNodeSchema */,\n\t\t\t);\n\n\t\t\tyield* getFieldDiscrepancies(\n\t\t\t\tcreateFieldSchema(FieldKind.Optional, view.info),\n\t\t\t\t(stored as MapNodeStoredSchema).mapFields,\n\t\t\t\tidentifier,\n\t\t\t\tundefined,\n\t\t\t);\n\t\t\tbreak;\n\t\t}\n\t\tcase NodeKind.Leaf: {\n\t\t\tassert(\n\t\t\t\tview instanceof LeafNodeSchema,\n\t\t\t\t0xbed /* schema with node kind of leaf must implement LeafNodeSchema */,\n\t\t\t);\n\t\t\t// TODO: leafKind seems like a bad name\n\t\t\tconst viewValue = view.leafKind;\n\t\t\tconst storedValue = (stored as LeafNodeStoredSchema).leafValue;\n\t\t\tif (viewValue !== storedValue) {\n\t\t\t\tyield {\n\t\t\t\t\tidentifier,\n\t\t\t\t\tmismatch: \"valueSchema\",\n\t\t\t\t\tview: viewValue,\n\t\t\t\t\tstored: storedValue,\n\t\t\t\t};\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tdefault:\n\t\t\tbreak;\n\t}\n}\n\n/**\n * Returns the allowed types that are not present in both the given view and stored schemas.\n * It returns a tuple containing two arrays:\n * 1. The first array contains the allowed types that are present in the view schema but not in the stored schema.\n * 2. The second array contains the allowed types that are present in the stored schema but not in the view schema.\n */\nexport function findExtraAllowedTypes(\n\tviewAllowedTypes: readonly AnnotatedAllowedType<TreeNodeSchema>[],\n\tstoredAllowedTypes: TreeTypeSet,\n): {\n\tviewExtra: readonly AnnotatedAllowedType<TreeNodeSchema>[];\n\tstoredExtra: TreeNodeSchemaIdentifier[];\n} {\n\tconst viewNodeSchemaIdentifiers = new Set(\n\t\tviewAllowedTypes.map((value) => value.type.identifier),\n\t);\n\n\tconst viewExtra = viewAllowedTypes.filter(\n\t\t(value) => !storedAllowedTypes.has(brand(value.type.identifier)),\n\t);\n\tconst storedExtra = [...storedAllowedTypes].filter(\n\t\t(value) => !viewNodeSchemaIdentifiers.has(value),\n\t);\n\treturn { viewExtra, storedExtra };\n}\n\n/**\n * The function to track the discrepancies between a field view schema and a stored schema.\n *\n * @remarks\n * This function yields discrepancies in the following cases:\n * 1. If the view schema has allowed types that are not present in the stored schema.\n * 2. If the stored schema has allowed types that are not present in the view schema.\n * 3. If the field kind in the view schema is not compatible with the stored schema.\n *\n * This function does not recurse into the nodes of the view schema and only makes comparisons at the field level.\n *\n * @param fieldKey - If the key is missing, it indicates that this is the root field schema.\n */\nfunction* getFieldDiscrepancies(\n\tview: FieldSchema,\n\tstored: TreeFieldStoredSchema,\n\tidentifier: TreeNodeSchemaIdentifier | undefined,\n\tfieldKey: FieldKey | undefined,\n): Iterable<FieldDiscrepancy> {\n\tassert(\n\t\tview instanceof FieldSchemaAlpha,\n\t\t0xbee /* all field schema should be FieldSchemaAlpha */,\n\t);\n\tyield* getAllowedTypeDiscrepancies(\n\t\tview.annotatedAllowedTypesNormalized.types,\n\t\tstored.types,\n\t\tidentifier,\n\t\tfieldKey,\n\t);\n\n\tconst viewKind =\n\t\tconvertFieldKind.get(view.kind) ??\n\t\tfail(0xbef /* A conversion from a FieldKind to a FlexFieldKind should exist */);\n\n\t// This checks if the field kind in the view schema is not compatible with the stored schema.\n\tif (viewKind.identifier !== stored.kind) {\n\t\tyield {\n\t\t\tidentifier,\n\t\t\tfieldKey,\n\t\t\tmismatch: \"fieldKind\",\n\t\t\tview: viewKind.identifier,\n\t\t\tstored: stored.kind,\n\t\t} satisfies FieldKindDiscrepancy;\n\t}\n}\n\n/**\n * The function to track the discrepancies between a field view schema and a stored schema.\n *\n * @remarks\n * This function yields discrepancies in the following cases:\n * 1. If the view schema has allowed types that are not present in the stored schema.\n * 2. If the stored schema has allowed types that are not present in the view schema.\n *\n * This function does not recurse into the nodes of the view schema and only makes comparisons at the field level.\n *\n * @param fieldKey - If the key is missing, it indicates that this is the root field schema.\n */\nfunction* getAllowedTypeDiscrepancies(\n\tview: readonly AnnotatedAllowedType<TreeNodeSchema>[],\n\tstored: TreeTypeSet,\n\tidentifier: TreeNodeSchemaIdentifier | undefined,\n\tfieldKey: FieldKey | undefined,\n): Iterable<FieldDiscrepancy> {\n\tconst { viewExtra, storedExtra } = findExtraAllowedTypes(view, stored);\n\tif (viewExtra.length > 0 || storedExtra.length > 0) {\n\t\tyield {\n\t\t\tidentifier,\n\t\t\tfieldKey,\n\t\t\tmismatch: \"allowedTypes\",\n\t\t\tview: viewExtra,\n\t\t\tstored: storedExtra,\n\t\t} satisfies AllowedTypeDiscrepancy;\n\t}\n}\n\n/**\n * Computes discrepancies between a view schema and a stored schema for nodes that are treated as object nodes in the stored schema.\n * This includes both view object nodes and view array nodes.\n *\n * This function yields discrepancies in the following cases:\n *\n * 1. If the view schema has fields that are not present in the stored schema.\n * 2. If the stored schema has fields that are not present in the view schema.\n * 3. If the field kind or allowed types of a field in the view schema is not compatible with the stored schema.\n *\n * This function includes discrepancies within the common fields and their allowed types, but does NOT recurse to report and discrepancies within the node types referenced by those fields.\n */\nfunction* computeObjectNodeDiscrepancies(\n\tidentifier: TreeNodeSchemaIdentifier,\n\tview: ObjectNodeSchemaPrivate,\n\tstored: ObjectNodeStoredSchema,\n): Iterable<FieldDiscrepancy> {\n\t/**\n\t * Similar to the logic used for tracking discrepancies between two node schemas, we will identify\n\t * three types of differences:\n\t * 1. Fields that exist in the view schema but not in the stored schema.\n\t * 2. Fields that exist in both schemas but have different contents.\n\t * 3. Fields that exist in the stored schema but not in the view schema.\n\t *\n\t * First, the view schema is iterated to track the first two types of differences.\n\t * Then, the stored schema is iterated to find the third type.\n\t */\n\n\tconst viewKeys = new Set<FieldKey>();\n\n\tfor (const [_, { storedKey: fieldKey, schema: fieldSchema }] of view.flexKeyMap) {\n\t\tconst storedSchema = stored.objectNodeFields.get(fieldKey);\n\t\tviewKeys.add(fieldKey);\n\n\t\t// If the view schema has a field that's not in the stored schema\n\t\tif (storedSchema === undefined) {\n\t\t\tconst viewKind =\n\t\t\t\tconvertFieldKind.get(fieldSchema.kind) ??\n\t\t\t\tfail(0xbf0 /* A conversion from a FieldKind to a FlexFieldKind should exist */);\n\t\t\tyield {\n\t\t\t\tidentifier,\n\t\t\t\tfieldKey,\n\t\t\t\tmismatch: \"fieldKind\",\n\t\t\t\tview: viewKind.identifier,\n\t\t\t\tstored: storedEmptyFieldSchema.kind,\n\t\t\t} satisfies FieldKindDiscrepancy;\n\t\t} else {\n\t\t\tyield* getFieldDiscrepancies(fieldSchema, storedSchema, identifier, fieldKey);\n\t\t}\n\t}\n\n\tfor (const [fieldKey, schema] of stored.objectNodeFields) {\n\t\tif (schema.kind === forbiddenFieldKindIdentifier) {\n\t\t\t// In the stored schema the field is explicitly forbidden.\n\t\t\t// This has the same semantics of the field not being mentioned in the stored schema,\n\t\t\t// and thus can be skipped.\n\t\t\tcontinue;\n\t\t}\n\n\t\t// If the stored schema has a field that's not in the view schema\n\t\tif (!viewKeys.has(fieldKey)) {\n\t\t\t// When the application has opted into it, we allow viewing documents which have additional\n\t\t\t// optional fields in the stored schema that are not present in the view schema.\n\t\t\tif (!view.allowUnknownOptionalFields || schema.kind !== FieldKinds.optional.identifier) {\n\t\t\t\tyield {\n\t\t\t\t\tidentifier,\n\t\t\t\t\tfieldKey,\n\t\t\t\t\tmismatch: \"fieldKind\",\n\t\t\t\t\tview: storedEmptyFieldSchema.kind,\n\t\t\t\t\tstored: schema.kind,\n\t\t\t\t} satisfies FieldKindDiscrepancy;\n\t\t\t}\n\t\t}\n\t}\n}\n"]}

package/dist/simple-tree/api/schemaCompatibilityTester.d.ts

@@ -3,21 +3,23 @@
  * Licensed under the MIT License.
  */
 import type { TreeStoredSchema } from "../../core/index.js";
-import { type FullSchemaPolicy } from "../../feature-libraries/index.js";
-import type { FieldSchema } from "../fieldSchema.js";
 import type { SchemaCompatibilityStatus } from "./tree.js";
+import type { TreeSchema } from "./configuration.js";
 /**
- * A collection of View information for schema, including policy.
+ * A collection of View information for schema
  * @remarks
  * This contains everything needed to determine compatibility with a given stored schema.
  */
 export declare class SchemaCompatibilityTester {
-    readonly policy: FullSchemaPolicy;
-    readonly viewSchemaRoot: FieldSchema;
     /**
-     * @param viewSchemaRoot - Schema for the root field.
+     * Schema for the view
      */
-    constructor(policy: FullSchemaPolicy, viewSchemaRoot: FieldSchema);
+    readonly viewSchema: TreeSchema;
+    constructor(
+    /**
+     * Schema for the view
+     */
+    viewSchema: TreeSchema);
     /**
      * Determines the compatibility of a stored document
      * (based on its stored schema) with a viewer (based on its view schema).

package/dist/simple-tree/api/schemaCompatibilityTester.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemaCompatibilityTester.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaCompatibilityTester.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAGN,KAAK,gBAAgB,EAErB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAU3D;;;;GAIG;AACH,qBAAa,yBAAyB;aAKpB,MAAM,EAAE,gBAAgB;aACxB,cAAc,EAAE,WAAW;IAL5C;;OAEG;gBAEc,MAAM,EAAE,gBAAgB,EACxB,cAAc,EAAE,WAAW;IAG5C;;;;;;;;;OASG;IACI,kBAAkB,CACxB,MAAM,EAAE,gBAAgB,GACtB,IAAI,CAAC,yBAAyB,EAAE,eAAe,CAAC;CAgJnD"}
+{"version":3,"file":"schemaCompatibilityTester.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/schemaCompatibilityTester.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAG3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;GAIG;AACH,qBAAa,yBAAyB;IAEpC;;OAEG;aACa,UAAU,EAAE,UAAU;;IAHtC;;OAEG;IACa,UAAU,EAAE,UAAU;IAGvC;;;;;;;;;OASG;IACI,kBAAkB,CACxB,MAAM,EAAE,gBAAgB,GACtB,IAAI,CAAC,yBAAyB,EAAE,eAAe,CAAC;CAkCnD"}

package/dist/simple-tree/api/schemaCompatibilityTester.js

@@ -5,22 +5,21 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaCompatibilityTester = void 0;
-const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../../feature-libraries/index.js");
-const discrepancies_js_1 = require("../discrepancies.js");
+const discrepancies_js_1 = require("./discrepancies.js");
 const toStoredSchema_js_1 = require("../toStoredSchema.js");
 /**
- * A collection of View information for schema, including policy.
+ * A collection of View information for schema
  * @remarks
  * This contains everything needed to determine compatibility with a given stored schema.
  */
 class SchemaCompatibilityTester {
+    constructor(
     /**
-     * @param viewSchemaRoot - Schema for the root field.
+     * Schema for the view
      */
-    constructor(policy, viewSchemaRoot) {
-        this.policy = policy;
-        this.viewSchemaRoot = viewSchemaRoot;
+    viewSchema) {
+        this.viewSchema = viewSchema;
     }
     /**
      * Determines the compatibility of a stored document
@@ -33,125 +32,27 @@ class SchemaCompatibilityTester {
      * It should be wrapped with (or replaced by) a parse style API.
      */
     checkCompatibility(stored) {
+        // The public API surface assumes defaultSchemaPolicy
+        const policy = index_js_1.defaultSchemaPolicy;
         // View schema allows a subset of documents that stored schema does, and the discrepancies are allowed by policy
         // determined by the view schema (i.e. objects with extra optional fields in the stored schema have opted into allowing this.
         // In the future, this would also include things like:
         // - fields with more allowed types in the stored schema than in the view schema have out-of-schema "unknown content" adapters
         let canView = true;
-        // View schema allows a superset of documents that stored schema does, hence the document could be upgraded to use a persisted version
-        // of this view schema as its stored schema.
-        let canUpgrade = true;
-        const updateCompatibilityFromFieldDiscrepancy = (discrepancy) => {
-            switch (discrepancy.mismatch) {
-                case "allowedTypes": {
-                    // Since we only track the symmetric difference between the allowed types in the view and
-                    // stored schemas, it's sufficient to check if any extra allowed types still exist in the
-                    // stored schema.
-                    if (discrepancy.stored.some((identifier) => !(0, index_js_1.isNeverTree)(this.policy, stored, stored.nodeSchema.get(identifier)))) {
-                        // Stored schema has extra allowed types that the view schema does not.
-                        canUpgrade = false;
-                        canView = false;
-                    }
-                    if (discrepancy.view.length > 0) {
-                        // View schema has extra allowed types that the stored schema does not.
-                        canView = false;
-                    }
-                    break;
-                }
-                case "fieldKind": {
-                    const result = (0, discrepancies_js_1.comparePosetElements)(discrepancy.stored, discrepancy.view, discrepancies_js_1.fieldRealizer);
-                    if (result === discrepancies_js_1.PosetComparisonResult.Greater) {
-                        // Stored schema is more relaxed than view schema.
-                        canUpgrade = false;
-                        if (discrepancy.view === index_js_1.FieldKinds.forbidden.identifier &&
-                            discrepancy.identifier !== undefined &&
-                            this.policy.allowUnknownOptionalFields(discrepancy.identifier)) {
-                            // When the application has opted into it, we allow viewing documents which have additional
-                            // optional fields in the stored schema that are not present in the view schema.
-                        }
-                        else {
-                            canView = false;
-                        }
-                    }
-                    if (result === discrepancies_js_1.PosetComparisonResult.Less) {
-                        // View schema is more relaxed than stored schema.
-                        canView = false;
-                    }
-                    if (result === discrepancies_js_1.PosetComparisonResult.Incomparable) {
-                        canUpgrade = false;
-                        canView = false;
-                    }
-                    break;
-                }
-                case "valueSchema": {
-                    canView = false;
-                    canUpgrade = false;
-                    break;
-                }
-                default:
-                    (0, internal_1.unreachableCase)(discrepancy);
-            }
-        };
-        for (const discrepancy of (0, discrepancies_js_1.getAllowedContentDiscrepancies)(this.viewSchemaRoot, stored)) {
-            if (!canView && !canUpgrade) {
-                break;
-            }
-            switch (discrepancy.mismatch) {
-                case "nodeKind": {
-                    const storedNodeSchema = stored.nodeSchema.get(discrepancy.identifier);
-                    // We conservatively do not allow node types to change.
-                    // The only time this might be valid in the sense that the data canonically converts is converting an object node
-                    // to a map node over the union of all the object fields' types.
-                    if (discrepancy.stored === undefined) {
-                        // View schema has added a node type that the stored schema doesn't know about.
-                        // Note that all cases which trigger this should also trigger an AllowedTypeDiscrepancy (where the type is used).
-                        // This means this case should be redundant and could be removed in the future if there is a reason to do so
-                        // (like simplifying enablable type support).
-                        // See the TODO in getAllowedContentDiscrepancies.
-                        canView = false;
-                    }
-                    else if (discrepancy.view === undefined) {
-                        const storedIsNever = storedNodeSchema !== undefined
-                            ? (0, index_js_1.isNeverTree)(this.policy, stored, storedNodeSchema)
-                            : true;
-                        if (!storedIsNever) {
-                            // Stored schema has a node type that the view schema doesn't know about.
-                            // The design of allowUnknownOptionalFields allows adding new optional content to types,
-                            // and the new optional content can use new types.
-                            // Therefore this case needs to be supported for viewing.
-                            // However, it is not supported for upgrade as the stored document must be newer (or at least more general) than the view in this case.
-                            // The fact that there might be removed trees with a root of this type which only appears in the stored schema is why this must set canUpgrade to false.
-                            canUpgrade = false;
-                        }
-                    }
-                    else {
-                        // Node type exists in both schemas but kind has changed. We conservatively never allow this.
-                        // See note above about cases where this could be allowed if needed.
-                        canView = false;
-                        canUpgrade = false;
-                    }
-                    break;
-                }
-                case "valueSchema":
-                case "allowedTypes":
-                case "fieldKind": {
-                    updateCompatibilityFromFieldDiscrepancy(discrepancy);
-                    break;
-                }
-                case "fields": {
-                    discrepancy.differences.forEach(updateCompatibilityFromFieldDiscrepancy);
-                    break;
-                }
-                // No default
-            }
-        }
-        if (canUpgrade) {
-            (0, internal_1.assert)((0, index_js_1.allowsRepoSuperset)(this.policy, stored, (0, toStoredSchema_js_1.toStoredSchema)(this.viewSchemaRoot)), 0xbf2 /* View schema must be a superset of the stored schema to allow upgrade */);
+        for (const _discrepancy of (0, discrepancies_js_1.getDiscrepanciesInAllowedContent)(this.viewSchema, stored)) {
+            canView = false;
+            break;
         }
+        const canUpgrade = (0, index_js_1.allowsRepoSuperset)(policy, stored, (0, toStoredSchema_js_1.toStoredSchema)(this.viewSchema.root));
+        // If true, then upgrading has no effect on what can be stored in the document.
+        // TODO: This should likely be changed to indicate up a schema upgrade would be a no-op, including stored schema metadata.
+        const isEquivalent = canView &&
+            canUpgrade &&
+            (0, index_js_1.allowsRepoSuperset)(policy, (0, toStoredSchema_js_1.toStoredSchema)(this.viewSchema.root), stored);
         return {
             canView,
             canUpgrade,
-            isEquivalent: canView && canUpgrade,
+            isEquivalent,
         };
     }
 }