@fluidframework/tree 2.50.0 → 2.51.0

package/dist/simple-tree/discrepancies.js

@@ -0,0 +1,382 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comparePosetElements = exports.PosetComparisonResult = exports.fieldRealizer = exports.findExtraAllowedTypes = exports.getAllowedContentDiscrepancies = 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 walkFieldSchema_js_1 = require("./walkFieldSchema.js");
+const fieldSchema_js_1 = require("./fieldSchema.js");
+const leafNodeSchema_js_1 = require("./leafNodeSchema.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);
+    }
+}
+function getViewNodeSchemaType(schema) {
+    switch (schema.kind) {
+        case index_js_3.NodeKind.Leaf: {
+            return index_js_1.LeafNodeStoredSchema;
+        }
+        case index_js_3.NodeKind.Map:
+        case index_js_3.NodeKind.Record: {
+            return index_js_1.MapNodeStoredSchema;
+        }
+        case index_js_3.NodeKind.Object:
+        case index_js_3.NodeKind.Array: {
+            return index_js_1.ObjectNodeStoredSchema;
+        }
+        default:
+            (0, internal_1.unreachableCase)(schema.kind);
+    }
+}
+/**
+ * Finds and reports discrepancies between a view schema and a stored schema.
+ *
+ * See documentation on {@link Discrepancy} for details of possible discrepancies.
+ * @remarks
+ * This function does not attempt to distinguish between equivalent representations of a node/field involving extraneous never trees.
+ * For example, a Forbidden field with allowed type set `[]` is equivalent to an optional field with allowed type set `[]`,
+ * as well as an optional field with an allowed type set containing only unconstructable types.
+ *
+ * It is up to the caller to determine whether such discrepancies matter.
+ */
+function* getAllowedContentDiscrepancies(view, stored) {
+    // check root schema discrepancies
+    yield* getFieldDiscrepancies(view, stored.rootFieldSchema, undefined, undefined);
+    const viewNodeSchema = new Map();
+    (0, walkFieldSchema_js_1.walkFieldSchema)(view, {
+        node: (schema) => {
+            const identifier = (0, index_js_2.brand)(schema.identifier);
+            (0, internal_1.debugAssert)(() => !viewNodeSchema.has(identifier));
+            viewNodeSchema.set(identifier, schema);
+        },
+    });
+    for (const [identifier, viewSchema] of viewNodeSchema) {
+        const storedSchema = stored.nodeSchema.get(identifier);
+        // if the view schema has a node that's not in the stored schema
+        if (storedSchema === undefined) {
+            const viewType = getViewNodeSchemaType(viewSchema);
+            // TODO does it make sense to have this mismatch when there will also be an allowedTypes mismatch?
+            yield {
+                identifier,
+                mismatch: "nodeKind",
+                view: viewType,
+                stored: undefined,
+            };
+        }
+        else {
+            yield* getNodeDiscrepancies(identifier, viewSchema, storedSchema);
+        }
+    }
+    for (const [identifier, storedSchema] of stored.nodeSchema) {
+        if (!viewNodeSchema.has(identifier)) {
+            const storedType = getStoredNodeSchemaType(storedSchema);
+            yield {
+                identifier,
+                mismatch: "nodeKind",
+                view: undefined,
+                stored: storedType,
+            };
+        }
+    }
+}
+exports.getAllowedContentDiscrepancies = getAllowedContentDiscrepancies;
+function* getNodeDiscrepancies(identifier, view, stored) {
+    if (!doesNodeKindMatchStoredNodeKind(view.kind, getStoredNodeSchemaType(stored))) {
+        yield {
+            identifier,
+            mismatch: "nodeKind",
+            view: getViewNodeSchemaType(view),
+            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 */);
+            const fields = view.flexKeyMap;
+            const differences = Array.from(computeObjectNodeDiscrepancies(identifier, fields, stored));
+            if (differences.length > 0) {
+                yield {
+                    identifier,
+                    mismatch: "fields",
+                    differences,
+                };
+            }
+            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 fields = new Map([
+                [
+                    index_js_1.EmptyKey,
+                    {
+                        storedKey: index_js_1.EmptyKey,
+                        schema: (0, fieldSchema_js_1.createFieldSchema)(fieldSchema_js_1.FieldKind.Optional, view.info),
+                    },
+                ],
+            ]);
+            const differences = Array.from(computeObjectNodeDiscrepancies(identifier, fields, stored, true));
+            if (differences.length > 0) {
+                yield {
+                    identifier,
+                    mismatch: "fields",
+                    differences,
+                };
+            }
+            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 viewExtraneousAllowedTypes = [...viewAllowedTypes].filter((value) => !storedAllowedTypes.has((0, index_js_2.brand)(value.type.identifier)));
+    const storedExtraneousAllowedTypes = [...storedAllowedTypes].filter((value) => !viewNodeSchemaIdentifiers.has(value));
+    return [viewExtraneousAllowedTypes, storedExtraneousAllowedTypes];
+}
+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 keyOrRoot - If the key is missing, it indicates that this is the root field schema.
+ */
+function* getFieldDiscrepancies(view, stored, identifier, fieldKey, 
+// TODO: This is a temporary workaround until the comparison logic is redesigned.
+viewKindIsSequence = false) {
+    (0, internal_1.assert)(view instanceof fieldSchema_js_1.FieldSchemaAlpha, 0xbee /* all field schema should be FieldSchemaAlpha */);
+    const [viewExtra, storedExtra] = findExtraAllowedTypes(view.annotatedAllowedTypesNormalized.types, stored.types);
+    if (viewExtra.length > 0 || storedExtra.length > 0) {
+        yield {
+            identifier,
+            fieldKey,
+            mismatch: "allowedTypes",
+            view: viewExtra,
+            stored: storedExtra,
+        };
+    }
+    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.
+    // We cannot detect if the view schema is a sequence using the kind property so it is passed in separately.
+    if ((viewKindIsSequence && stored.kind !== "Sequence") ||
+        (!viewKindIsSequence && viewKind.identifier !== stored.kind)) {
+        yield {
+            identifier,
+            fieldKey,
+            mismatch: "fieldKind",
+            view: viewKind.identifier,
+            stored: stored.kind,
+        };
+    }
+}
+/**
+ * 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, viewKindIsSequence = false) {
+    /**
+     * 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) {
+        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, viewKindIsSequence);
+        }
+    }
+    for (const [fieldKey, schema] of stored.objectNodeFields) {
+        // If the stored schema has a field that's not in the view schema
+        if (!viewKeys.has(fieldKey)) {
+            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 is compatible with the view schema which does not mention this field.
+                continue;
+            }
+            yield {
+                identifier,
+                fieldKey,
+                mismatch: "fieldKind",
+                view: index_js_1.storedEmptyFieldSchema.kind,
+                stored: schema.kind,
+            };
+        }
+    }
+}
+/**
+ * @privateRemarks
+ * TODO: Knowledge of specific field kinds is not appropriate for modular schema.
+ * This bit of field comparison should be dependency injected by default-schema if this comparison logic remains in modular-schema
+ * (this is analogous to what is done in comparison.ts).
+ */
+const FieldKindIdentifiers = {
+    forbidden: (0, index_js_2.brand)("Forbidden"),
+    required: (0, index_js_2.brand)("Value"),
+    identifier: (0, index_js_2.brand)("Identifier"),
+    optional: (0, index_js_2.brand)("Optional"),
+    sequence: (0, index_js_2.brand)("Sequence"),
+};
+/**
+ * A realizer for the partial order of field kind relaxability.
+ *
+ * It seems extremely likely that this partial order will remain dimension 2 over time (i.e. the set of allowed relaxations can be visualized
+ * with a [dominance drawing](https://en.wikipedia.org/wiki/Dominance_drawing)), so this strategy allows efficient comarison between field kinds
+ * without excessive casework.
+ *
+ * Hasse diagram for the partial order is shown below (lower fields can be relaxed to higher fields):
+ * ```
+ * sequence
+ *    |
+ * optional
+ *    |    \
+ * required forbidden
+ *    |
+ * identifier
+ * ```
+ */
+exports.fieldRealizer = [
+    [
+        FieldKindIdentifiers.forbidden,
+        FieldKindIdentifiers.identifier,
+        FieldKindIdentifiers.required,
+        FieldKindIdentifiers.optional,
+        FieldKindIdentifiers.sequence,
+    ],
+    [
+        FieldKindIdentifiers.identifier,
+        FieldKindIdentifiers.required,
+        FieldKindIdentifiers.forbidden,
+        FieldKindIdentifiers.optional,
+        FieldKindIdentifiers.sequence,
+    ],
+].map((extension) => new Map(extension.map((identifier, index) => [identifier, index])));
+exports.PosetComparisonResult = {
+    Less: "<",
+    Greater: ">",
+    Equal: "=",
+    Incomparable: "||",
+};
+/**
+ * TODO: This is used by SchemaCompatibilityTester, revisit it during redesign and document
+ */
+function comparePosetElements(a, b, realizer) {
+    let hasLessThanResult = false;
+    let hasGreaterThanResult = false;
+    for (const extension of realizer) {
+        const aIndex = extension.get(a);
+        const bIndex = extension.get(b);
+        (0, internal_1.assert)(aIndex !== undefined && bIndex !== undefined, 0xbf1 /* Invalid realizer */);
+        if (aIndex < bIndex) {
+            hasLessThanResult = true;
+        }
+        else if (aIndex > bIndex) {
+            hasGreaterThanResult = true;
+        }
+    }
+    return hasLessThanResult
+        ? hasGreaterThanResult
+            ? exports.PosetComparisonResult.Incomparable
+            : exports.PosetComparisonResult.Less
+        : hasGreaterThanResult
+            ? exports.PosetComparisonResult.Greater
+            : exports.PosetComparisonResult.Equal;
+}
+exports.comparePosetElements = comparePosetElements;
+//# sourceMappingURL=discrepancies.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"discrepancies.js","sourceRoot":"","sources":["../../src/simple-tree/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 {\n\tassert,\n\tdebugAssert,\n\tfail,\n\tunreachableCase,\n} 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 { NodeKind, type AnnotatedAllowedType, type TreeNodeSchema } from \"./core/index.js\";\nimport {\n\tisArrayNodeSchema,\n\tisMapNodeSchema,\n\tisObjectNodeSchema,\n\tisRecordNodeSchema,\n\ttype SimpleKeyMap,\n} from \"./node-kinds/index.js\";\nimport { convertFieldKind } from \"./toStoredSchema.js\";\nimport { walkFieldSchema } from \"./walkFieldSchema.js\";\nimport {\n\tcreateFieldSchema,\n\tFieldKind,\n\tFieldSchemaAlpha,\n\ttype FieldSchema,\n} from \"./fieldSchema.js\";\nimport { LeafNodeSchema } from \"./leafNodeSchema.js\";\n\n/**\n * Discriminated union (keyed on `mismatch`) of discrepancies between a view and stored schema.\n * @remarks\n *\n * 1. FieldDiscrepancy\n *\n * `FieldDiscrepancy` represents the differences between two `TreeFieldStoredSchema` objects. It consists of\n * three types of incompatibilities:\n *\n * - FieldKindDiscrepancy: Indicates the differences in `FieldKindIdentifier` between two `TreeFieldStoredSchema`\n * objects (e.g., optional, required, sequence, etc.).\n * - AllowedTypesDiscrepancy: Indicates the differences in the allowed child types between the two schemas.\n * - ValueSchemaDiscrepancy: Specifically indicates the differences in the `ValueSchema` of two\n * `LeafNodeStoredSchema` objects.\n *\n * 2. NodeDiscrepancy\n *\n * `NodeDiscrepancy` represents the differences between two `TreeNodeStoredSchema` objects and includes:\n *\n * - NodeKindDiscrepancy: Indicates the differences in the types of `TreeNodeStoredSchema` (currently supports\n * `ObjectNodeStoredSchema`, `MapNodeStoredSchema`, and `LeafNodeStoredSchema`).\n * - NodeFieldsDiscrepancy: Indicates the `FieldDiscrepancy` of `TreeFieldStoredSchema` within two\n * `TreeNodeStoredSchema`. It includes an array of `FieldDiscrepancy` instances in the `differences` field.\n *\n * When comparing two nodes for compatibility, it only makes sense to compare their fields if the nodes are of\n * the same kind (map, object, leaf).\n *\n * 3. Discrepancy\n *\n * Discrepancy consists of both `NodeDiscrepancy` and `FieldDiscrepancy`, representing any kind of\n * schema differences. See {@link getAllowedContentDiscrepancies} for more details about how we process it\n * and the ordering.\n */\nexport type Discrepancy = FieldDiscrepancy | NodeDiscrepancy;\n\nexport type NodeDiscrepancy = NodeKindDiscrepancy | NodeFieldsDiscrepancy;\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 in view/stored to enable more efficient checks for compatibility\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\nexport interface FieldKindDiscrepancy extends FieldDiscrepancyLocation {\n\treadonly mismatch: \"fieldKind\";\n\treadonly view: FieldKindIdentifier;\n\treadonly stored: FieldKindIdentifier;\n}\n\nexport interface ValueSchemaDiscrepancy {\n\tidentifier: TreeNodeSchemaIdentifier;\n\tmismatch: \"valueSchema\";\n\tview: ValueSchema | undefined;\n\tstored: ValueSchema | undefined;\n}\n\nexport interface NodeKindDiscrepancy {\n\tidentifier: TreeNodeSchemaIdentifier;\n\tmismatch: \"nodeKind\";\n\tview: SchemaFactoryNodeKind | undefined;\n\tstored: SchemaFactoryNodeKind | undefined;\n}\n\nexport interface NodeFieldsDiscrepancy {\n\tidentifier: TreeNodeSchemaIdentifier;\n\tmismatch: \"fields\";\n\tdifferences: FieldDiscrepancy[];\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\nfunction getViewNodeSchemaType(schema: TreeNodeSchema): SchemaFactoryNodeKind {\n\tswitch (schema.kind) {\n\t\tcase NodeKind.Leaf: {\n\t\t\treturn LeafNodeStoredSchema;\n\t\t}\n\t\tcase NodeKind.Map:\n\t\tcase NodeKind.Record: {\n\t\t\treturn MapNodeStoredSchema;\n\t\t}\n\t\tcase NodeKind.Object:\n\t\tcase NodeKind.Array: {\n\t\t\treturn ObjectNodeStoredSchema;\n\t\t}\n\t\tdefault:\n\t\t\tunreachableCase(schema.kind);\n\t}\n}\n\n/**\n * Finds and reports discrepancies between a view schema and a stored schema.\n *\n * See documentation on {@link Discrepancy} for details of possible discrepancies.\n * @remarks\n * This function does not attempt to distinguish between equivalent representations of a node/field involving extraneous never trees.\n * For example, a Forbidden field with allowed type set `[]` is equivalent to an optional field with allowed type set `[]`,\n * as well as an optional field with an allowed type set containing only unconstructable types.\n *\n * It is up to the caller to determine whether such discrepancies matter.\n */\nexport function* getAllowedContentDiscrepancies(\n\tview: FieldSchema,\n\tstored: TreeStoredSchema,\n): Iterable<Discrepancy> {\n\t// check root schema discrepancies\n\tyield* getFieldDiscrepancies(view, stored.rootFieldSchema, undefined, undefined);\n\n\tconst viewNodeSchema = new Map<TreeNodeSchemaIdentifier, TreeNodeSchema>();\n\n\twalkFieldSchema(view, {\n\t\tnode: (schema) => {\n\t\t\tconst identifier: TreeNodeSchemaIdentifier = brand(schema.identifier);\n\n\t\t\tdebugAssert(() => !viewNodeSchema.has(identifier));\n\t\t\tviewNodeSchema.set(identifier, schema);\n\t\t},\n\t});\n\n\tfor (const [identifier, viewSchema] of viewNodeSchema) {\n\t\tconst storedSchema = stored.nodeSchema.get(identifier);\n\n\t\t// if the view schema has a node that's not in the stored schema\n\t\tif (storedSchema === undefined) {\n\t\t\tconst viewType = getViewNodeSchemaType(viewSchema);\n\t\t\t// TODO does it make sense to have this mismatch when there will also be an allowedTypes mismatch?\n\t\t\tyield {\n\t\t\t\tidentifier,\n\t\t\t\tmismatch: \"nodeKind\",\n\t\t\t\tview: viewType,\n\t\t\t\tstored: undefined,\n\t\t\t};\n\t\t} else {\n\t\t\tyield* getNodeDiscrepancies(identifier, viewSchema, storedSchema);\n\t\t}\n\t}\n\n\tfor (const [identifier, storedSchema] of stored.nodeSchema) {\n\t\tif (!viewNodeSchema.has(identifier)) {\n\t\t\tconst storedType = getStoredNodeSchemaType(storedSchema);\n\t\t\tyield {\n\t\t\t\tidentifier,\n\t\t\t\tmismatch: \"nodeKind\",\n\t\t\t\tview: undefined,\n\t\t\t\tstored: storedType,\n\t\t\t};\n\t\t}\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: getViewNodeSchemaType(view),\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\tconst fields: SimpleKeyMap | undefined = view.flexKeyMap;\n\t\t\tconst differences = Array.from(\n\t\t\t\tcomputeObjectNodeDiscrepancies(identifier, fields, stored as ObjectNodeStoredSchema),\n\t\t\t);\n\n\t\t\tif (differences.length > 0) {\n\t\t\t\tyield {\n\t\t\t\t\tidentifier,\n\t\t\t\t\tmismatch: \"fields\",\n\t\t\t\t\tdifferences,\n\t\t\t\t} satisfies NodeFieldsDiscrepancy;\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\t\t\tconst fields: SimpleKeyMap = new Map([\n\t\t\t\t[\n\t\t\t\t\tEmptyKey,\n\t\t\t\t\t{\n\t\t\t\t\t\tstoredKey: EmptyKey,\n\t\t\t\t\t\tschema: createFieldSchema(FieldKind.Optional, view.info),\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t]);\n\n\t\t\tconst differences = Array.from(\n\t\t\t\tcomputeObjectNodeDiscrepancies(\n\t\t\t\t\tidentifier,\n\t\t\t\t\tfields,\n\t\t\t\t\tstored as ObjectNodeStoredSchema,\n\t\t\t\t\ttrue,\n\t\t\t\t),\n\t\t\t);\n\n\t\t\tif (differences.length > 0) {\n\t\t\t\tyield {\n\t\t\t\t\tidentifier,\n\t\t\t\t\tmismatch: \"fields\",\n\t\t\t\t\tdifferences,\n\t\t\t\t} satisfies NodeFieldsDiscrepancy;\n\t\t\t}\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): [readonly AnnotatedAllowedType<TreeNodeSchema>[], TreeNodeSchemaIdentifier[]] {\n\tconst viewNodeSchemaIdentifiers = new Set(\n\t\tviewAllowedTypes.map((value) => value.type.identifier),\n\t);\n\tconst viewExtraneousAllowedTypes = [...viewAllowedTypes].filter(\n\t\t(value) => !storedAllowedTypes.has(brand(value.type.identifier)),\n\t);\n\tconst storedExtraneousAllowedTypes = [...storedAllowedTypes].filter(\n\t\t(value) => !viewNodeSchemaIdentifiers.has(value),\n\t);\n\treturn [viewExtraneousAllowedTypes, storedExtraneousAllowedTypes];\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 keyOrRoot - 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\t// TODO: This is a temporary workaround until the comparison logic is redesigned.\n\tviewKindIsSequence = false,\n): Iterable<FieldDiscrepancy> {\n\tassert(\n\t\tview instanceof FieldSchemaAlpha,\n\t\t0xbee /* all field schema should be FieldSchemaAlpha */,\n\t);\n\tconst [viewExtra, storedExtra] = findExtraAllowedTypes(\n\t\tview.annotatedAllowedTypesNormalized.types,\n\t\tstored.types,\n\t);\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\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\t// We cannot detect if the view schema is a sequence using the kind property so it is passed in separately.\n\tif (\n\t\t(viewKindIsSequence && stored.kind !== \"Sequence\") ||\n\t\t(!viewKindIsSequence && viewKind.identifier !== stored.kind)\n\t) {\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 * 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: SimpleKeyMap,\n\tstored: ObjectNodeStoredSchema,\n\tviewKindIsSequence = false,\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) {\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(\n\t\t\t\tfieldSchema,\n\t\t\t\tstoredSchema,\n\t\t\t\tidentifier,\n\t\t\t\tfieldKey,\n\t\t\t\tviewKindIsSequence,\n\t\t\t);\n\t\t}\n\t}\n\n\tfor (const [fieldKey, schema] of stored.objectNodeFields) {\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\tif (schema.kind === forbiddenFieldKindIdentifier) {\n\t\t\t\t// In the stored schema the field is explicitly forbidden.\n\t\t\t\t// This has the same semantics of the field not being mentioned in the stored schema,\n\t\t\t\t// and thus is compatible with the view schema which does not mention this field.\n\t\t\t\tcontinue;\n\t\t\t}\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: storedEmptyFieldSchema.kind,\n\t\t\t\tstored: schema.kind,\n\t\t\t} satisfies FieldKindDiscrepancy;\n\t\t}\n\t}\n}\n\n/**\n * A linear extension of a partially-ordered set of `T`s. See:\n * https://en.wikipedia.org/wiki/Linear_extension\n *\n * The linear extension is represented as a lookup from each poset element to its index in the linear extension.\n */\nexport type LinearExtension<T> = Map<T, number>;\n\n/**\n * A realizer for a partially-ordered set. See:\n * https://en.wikipedia.org/wiki/Order_dimension\n */\nexport type Realizer<T> = LinearExtension<T>[];\n\n/**\n * @privateRemarks\n * TODO: Knowledge of specific field kinds is not appropriate for modular schema.\n * This bit of field comparison should be dependency injected by default-schema if this comparison logic remains in modular-schema\n * (this is analogous to what is done in comparison.ts).\n */\nconst FieldKindIdentifiers = {\n\tforbidden: brand<FieldKindIdentifier>(\"Forbidden\"),\n\trequired: brand<FieldKindIdentifier>(\"Value\"),\n\tidentifier: brand<FieldKindIdentifier>(\"Identifier\"),\n\toptional: brand<FieldKindIdentifier>(\"Optional\"),\n\tsequence: brand<FieldKindIdentifier>(\"Sequence\"),\n};\n\n/**\n * A realizer for the partial order of field kind relaxability.\n *\n * It seems extremely likely that this partial order will remain dimension 2 over time (i.e. the set of allowed relaxations can be visualized\n * with a [dominance drawing](https://en.wikipedia.org/wiki/Dominance_drawing)), so this strategy allows efficient comarison between field kinds\n * without excessive casework.\n *\n * Hasse diagram for the partial order is shown below (lower fields can be relaxed to higher fields):\n * ```\n * sequence\n *    |\n * optional\n *    |    \\\n * required forbidden\n *    |\n * identifier\n * ```\n */\nexport const fieldRealizer: Realizer<FieldKindIdentifier> = [\n\t[\n\t\tFieldKindIdentifiers.forbidden,\n\t\tFieldKindIdentifiers.identifier,\n\t\tFieldKindIdentifiers.required,\n\t\tFieldKindIdentifiers.optional,\n\t\tFieldKindIdentifiers.sequence,\n\t],\n\t[\n\t\tFieldKindIdentifiers.identifier,\n\t\tFieldKindIdentifiers.required,\n\t\tFieldKindIdentifiers.forbidden,\n\t\tFieldKindIdentifiers.optional,\n\t\tFieldKindIdentifiers.sequence,\n\t],\n].map((extension) => new Map(extension.map((identifier, index) => [identifier, index])));\n\nexport const PosetComparisonResult = {\n\tLess: \"<\",\n\tGreater: \">\",\n\tEqual: \"=\",\n\tIncomparable: \"||\",\n} as const;\ntype PosetComparisonResult =\n\t(typeof PosetComparisonResult)[keyof typeof PosetComparisonResult];\n\n/**\n * TODO: This is used by SchemaCompatibilityTester, revisit it during redesign and document\n */\nexport function comparePosetElements<T>(\n\ta: T,\n\tb: T,\n\trealizer: Realizer<T>,\n): PosetComparisonResult {\n\tlet hasLessThanResult = false;\n\tlet hasGreaterThanResult = false;\n\tfor (const extension of realizer) {\n\t\tconst aIndex = extension.get(a);\n\t\tconst bIndex = extension.get(b);\n\t\tassert(aIndex !== undefined && bIndex !== undefined, 0xbf1 /* Invalid realizer */);\n\t\tif (aIndex < bIndex) {\n\t\t\thasLessThanResult = true;\n\t\t} else if (aIndex > bIndex) {\n\t\t\thasGreaterThanResult = true;\n\t\t}\n\t}\n\n\treturn hasLessThanResult\n\t\t? hasGreaterThanResult\n\t\t\t? PosetComparisonResult.Incomparable\n\t\t\t: PosetComparisonResult.Less\n\t\t: hasGreaterThanResult\n\t\t\t? PosetComparisonResult.Greater\n\t\t\t: PosetComparisonResult.Equal;\n}\n"]}