@reventlessdev/reventless-core 3.0.0-alpha.239 → 3.0.0-alpha.240

package/src/plugin/component/Plugin_Structure.res.mjs

@@ -65,9 +65,7 @@ let conventionalLabelNames = [
   "displayname"
 ];
 
-function shapeOfItem(entityName, item) {
-  return SchemaType$ReventlessCore.fromSury(entityName, item.location, item.schema);
-}
+let shapeOfField = SchemaType$ReventlessCore.fromSury;
 
 function lifecycleFieldFromStateSchema(entityName, stateSchema) {
   let spec = StateAnnotations$Reventless.getSpec(stateSchema);
@@ -75,13 +73,11 @@ function lifecycleFieldFromStateSchema(entityName, stateSchema) {
   if (annotated !== undefined) {
     return annotated;
   } else if (stateSchema.type === "object") {
-    return Stdlib_Option.map(stateSchema.items.find(item => {
-      if (item.location === "lifecycle") {
-        return isLifecycleShape(shapeOfItem(entityName, item));
-      } else {
-        return false;
+    return Stdlib_Option.flatMap(stateSchema.properties["lifecycle"], schema => {
+      if (isLifecycleShape(SchemaType$ReventlessCore.fromSury(entityName, "lifecycle", schema))) {
+        return "lifecycle";
       }
-    }), item => item.location);
+    });
   } else {
     return;
   }
@@ -122,8 +118,8 @@ function checkRetiredValue(entityName, stateSchema) {
     log.warn("Plugin_Structure", undefined, entityName + `: @retired(` + named + `) is on "` + field + `", which is not this record's lifecycle field` + Stdlib_Option.getOr(Stdlib_Option.map(lifecycle, f => ` (that is "` + f + `")`), " (it declares none)") + `. A retirement state no command's @transition can name loses the command filtering the state form exists for.`);
   }
   let declared;
-  declared = stateSchema.type === "object" ? Stdlib_Option.getOr(Stdlib_Option.map(stateSchema.items.find(item => item.location === field), item => {
-      let match = shapeOfItem(entityName, item);
+  declared = stateSchema.type === "object" ? Stdlib_Option.getOr(Stdlib_Option.map(stateSchema.properties[field], schema => {
+      let match = SchemaType$ReventlessCore.fromSury(entityName, field, schema);
       if (typeof match !== "object") {
         return [];
       }
@@ -168,8 +164,8 @@ function reportRetiredStates(pluginName, failures, unchecked) {
 function lifecycleStatesFromStateSchema(entityName, stateSchema) {
   return Stdlib_Option.flatMap(lifecycleFieldFromStateSchema(entityName, stateSchema), field => {
     if (stateSchema.type === "object") {
-      return Stdlib_Option.map(stateSchema.items.find(item => item.location === field), item => {
-        let match = shapeOfItem(entityName, item);
+      return Stdlib_Option.map(stateSchema.properties[field], schema => {
+        let match = SchemaType$ReventlessCore.fromSury(entityName, field, schema);
         if (typeof match !== "object") {
           return [];
         }
@@ -235,29 +231,17 @@ function lifecycleTopologyFindings(writables, lifecycleStatesByView) {
   Object.entries(lifecycleStatesByView).forEach(param => {
     let states = param[1];
     let view = param[0];
-    let edges = Stdlib_Array.reduce(writables, [], (acc, w) => {
+    let reachable = Stdlib_Array.reduce(writables, [], (acc, w) => {
       if (w.linkedViews.includes(view)) {
-        return acc.concat(Stdlib_Array.reduce(w.commands, [], (inner, cmd) => {
-          let match = cmd.allowedStates;
-          let match$1 = cmd.targetState;
-          if (match !== undefined && match$1 !== undefined) {
-            return inner.concat(match.map(from => [
-              from,
-              match$1
-            ]));
-          } else {
-            return inner;
-          }
-        }));
+        return acc.concat(Stdlib_Array.filterMap(w.commands, cmd => cmd.targetState));
       } else {
         return acc;
       }
     });
-    if (edges.length === 0) {
+    if (reachable.length === 0) {
       return;
     }
     let initial = states[0];
-    let reachable = edges.map(param => param[1]);
     states.forEach(state => {
       if (!reachable.includes(state) && Primitive_object.notequal(state, initial)) {
         findings.push([
@@ -298,29 +282,30 @@ function labelFieldsFromStateSchema(entityName, stateSchema) {
     };
   }
   let candidates;
-  candidates = stateSchema.type === "object" ? stateSchema.items.filter(item => {
-      if (item.location !== "TAG" && item.location !== "id") {
-        return isLabelShape(shapeOfItem(entityName, item));
+  candidates = stateSchema.type === "object" ? Object.entries(stateSchema.properties).filter(param => {
+      let name = param[0];
+      if (name !== "TAG" && name !== "id") {
+        return isLabelShape(SchemaType$ReventlessCore.fromSury(entityName, name, param[1]));
       } else {
         return false;
       }
     }) : [];
-  let conventional = candidates.find(item => {
-    let lower = item.location.toLowerCase();
+  let conventional = candidates.find(param => {
+    let lower = param[0].toLowerCase();
     return conventionalLabelNames.some(n => n === lower);
   });
   let picked = conventional !== undefined ? [
-      conventional,
+      conventional[0],
       "Convention"
-    ] : Stdlib_Option.map(candidates[0], item => [
-      item,
+    ] : Stdlib_Option.map(candidates[0], param => [
+      param[0],
       "Position"
     ]);
   if (picked !== undefined) {
-    let item = picked[0];
+    let name = picked[0];
     return {
-      field: item.location,
-      searchableFields: [item.location],
+      field: name,
+      searchableFields: [name],
       source: picked[1]
     };
   }
@@ -377,7 +362,7 @@ function toEventDef(v) {
 }
 
 function extractEventDefs(eventSchema) {
-  if (eventSchema.type === "union") {
+  if (eventSchema.type === "anyOf") {
     return Stdlib_Array.filterMap(eventSchema.anyOf, toEventDef);
   } else {
     return Stdlib_Option.mapOr(toEventDef(eventSchema), [], def => [def]);
@@ -392,19 +377,8 @@ function extractErrorDefs(errorSchema) {
   }));
 }
 
-function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionsOpt, extensionPointsOpt, componentChaptersOpt) {
-  let aggregates = aggregatesOpt !== undefined ? aggregatesOpt : [];
-  let readModels = readModelsOpt !== undefined ? readModelsOpt : [];
-  let stateViewSlices = stateViewSlicesOpt !== undefined ? stateViewSlicesOpt : [];
-  let stateChangeSlices = stateChangeSlicesOpt !== undefined ? stateChangeSlicesOpt : [];
-  let automationSlices = automationSlicesOpt !== undefined ? automationSlicesOpt : [];
-  let outboundTranslationSlices = outboundTranslationSlicesOpt !== undefined ? outboundTranslationSlicesOpt : [];
-  let inboundTranslationSlices = inboundTranslationSlicesOpt !== undefined ? inboundTranslationSlicesOpt : [];
-  let extensions = extensionsOpt !== undefined ? extensionsOpt : [];
-  let extensionPoints = extensionPointsOpt !== undefined ? extensionPointsOpt : [];
-  let componentChapters = componentChaptersOpt !== undefined ? componentChaptersOpt : ({});
-  let qualify = (prefix, names) => names.map(n => prefix + "." + n);
-  let isCreateCommandName = name => [
+function isCreateCommandName(name) {
+  return [
     "Add",
     "Create",
     "Register",
@@ -414,135 +388,193 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     "Start",
     "Place"
   ].some(p => name.startsWith(p));
-  let commandLevelAndId = (isAggregate, variantName, properties) => {
-    if (isAggregate) {
-      if (isCreateCommandName(variantName)) {
-        return [
-          "Collection",
-          undefined
-        ];
-      } else {
-        return [
-          "Instance",
-          undefined
-        ];
-      }
-    }
-    let taggedFields = Object.entries(properties).filter(param => {
-      let fieldSchema = param[1];
-      if (param[0] !== "TAG") {
-        if (DcbTag$Reventless.isTagged(fieldSchema)) {
-          return true;
-        } else {
-          return DcbTag$Reventless.isTaggedArray(fieldSchema);
-        }
-      } else {
-        return false;
-      }
-    });
-    let taggedField = Stdlib_Option.orElse(taggedFields.find(param => DcbTag$Reventless.isPartitionTag(param[1])), taggedFields[0]);
-    if (taggedField === undefined) {
-      return [
-        "Collection",
-        undefined
-      ];
-    }
-    let fieldName = taggedField[0];
+}
+
+function commandLevelAndId(isAggregate, variantName, properties) {
+  if (isAggregate) {
     if (isCreateCommandName(variantName)) {
       return [
         "Collection",
-        fieldName
+        undefined
       ];
     } else {
       return [
         "Instance",
-        fieldName
+        undefined
       ];
     }
-  };
-  let accessKeysFor = rule => {
-    if (typeof rule !== "object") {
-      return;
+  }
+  let taggedFields = Object.entries(properties).filter(param => {
+    let fieldSchema = param[1];
+    if (param[0] !== "TAG") {
+      if (DcbTag$Reventless.isTagged(fieldSchema)) {
+        return true;
+      } else {
+        return DcbTag$Reventless.isTaggedArray(fieldSchema);
+      }
+    } else {
+      return false;
     }
-    let groups = rule._0;
-    if (groups.length !== 0) {
-      return groups;
+  });
+  let taggedField = Stdlib_Option.orElse(taggedFields.find(param => DcbTag$Reventless.isPartitionTag(param[1])), taggedFields[0]);
+  if (taggedField === undefined) {
+    return [
+      "Collection",
+      undefined
+    ];
+  }
+  let fieldName = taggedField[0];
+  if (isCreateCommandName(variantName)) {
+    return [
+      "Collection",
+      fieldName
+    ];
+  } else {
+    return [
+      "Instance",
+      fieldName
+    ];
+  }
+}
+
+function accessKeysFor(rule) {
+  if (typeof rule !== "object") {
+    return;
+  }
+  let groups = rule._0;
+  if (groups.length !== 0) {
+    return groups;
+  }
+}
+
+function annotateArgTypes(schema, argTypes) {
+  Stdlib_Option.forEach(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(schema), o => o["properties"]), Stdlib_JSON.Decode.object), props => {
+    Object.entries(props).forEach(param => {
+      let match = argTypes[param[0]];
+      let match$1 = Stdlib_JSON.Decode.object(param[1]);
+      if (match !== undefined && match$1 !== undefined) {
+        match$1["x-reventless-graphql-type"] = match;
+        return;
+      }
+    });
+  });
+  return schema;
+}
+
+function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthorization, v) {
+  let mkDef = (variantName, properties) => {
+    let match = commandLevelAndId(isAggregate, variantName, properties);
+    let references = extractReferences(properties);
+    let allowedStates = ApiAllowedStatesHelpers$ReventlessCore.getAllowedStates(parentSchema, variantName);
+    let targetState = ApiTargetStateHelpers$ReventlessCore.getTargetState(parentSchema, variantName);
+    let apiExposed = false;
+    if (!ApiNoApiHelpers$ReventlessCore.isNoApi(parentSchema)) {
+      let excluded = ApiNoApiHelpers$ReventlessCore.getExcludedVariants(parentSchema);
+      apiExposed = excluded !== undefined ? !excluded.has(variantName) : true;
     }
+    let syntheticCommand = DcbTag$Reventless.isVariantPayloadBearing(parentSchema, variantName) ? ({
+        TAG: variantName
+      }) : variantName;
+    let requiredAccess = accessKeysFor(commandAuthorization(syntheticCommand));
+    let mutationField = apiExposed ? mutationFieldFor(variantName) : "";
+    let jsonSchema = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(v);
+    let annotatedSchema = apiExposed ? Stdlib_Option.mapOr(GraphQL_FragmentGenerator$ReventlessCore.mutationArgTypes(mutationField, v), jsonSchema, __x => annotateArgTypes(jsonSchema, __x)) : jsonSchema;
+    return {
+      name: variantName,
+      schema: JSON.stringify(annotatedSchema),
+      level: match[0],
+      aggregateIdField: match[1],
+      mutationField: mutationField,
+      references: references,
+      allowedStates: allowedStates,
+      targetState: targetState,
+      apiExposed: apiExposed,
+      requiredAccess: requiredAccess,
+      ownerField: Owner$Reventless.fieldNamesOfProperties(properties)[0]
+    };
   };
-  let toCommandDef = (isAggregate, mutationFieldFor, parentSchema, commandAuthorization, v) => {
-    let mkDef = (variantName, properties) => {
-      let match = commandLevelAndId(isAggregate, variantName, properties);
-      let references = extractReferences(properties);
-      let allowedStates = ApiAllowedStatesHelpers$ReventlessCore.getAllowedStates(parentSchema, variantName);
-      let targetState = ApiTargetStateHelpers$ReventlessCore.getTargetState(parentSchema, variantName);
-      let apiExposed = false;
-      if (!ApiNoApiHelpers$ReventlessCore.isNoApi(parentSchema)) {
-        let excluded = ApiNoApiHelpers$ReventlessCore.getExcludedVariants(parentSchema);
-        apiExposed = excluded !== undefined ? !excluded.has(variantName) : true;
+  switch (v.type) {
+    case "string" :
+      let variantName = v.const;
+      if (variantName !== undefined) {
+        return mkDef(variantName, {});
+      } else {
+        return;
       }
-      let syntheticCommand = DcbTag$Reventless.isVariantPayloadBearing(parentSchema, variantName) ? ({
-          TAG: variantName
-        }) : variantName;
-      let requiredAccess = accessKeysFor(commandAuthorization(syntheticCommand));
-      let mutationField = apiExposed ? mutationFieldFor(variantName) : "";
-      let jsonSchema = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(v);
-      let annotatedSchema = apiExposed ? Stdlib_Option.mapOr(GraphQL_FragmentGenerator$ReventlessCore.mutationArgTypes(mutationField, v), jsonSchema, __x => {
-          Stdlib_Option.forEach(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(jsonSchema), o => o["properties"]), Stdlib_JSON.Decode.object), props => {
-            Object.entries(props).forEach(param => {
-              let match = __x[param[0]];
-              let match$1 = Stdlib_JSON.Decode.object(param[1]);
-              if (match !== undefined && match$1 !== undefined) {
-                match$1["x-reventless-graphql-type"] = match;
-                return;
-              }
-            });
-          });
-          return jsonSchema;
-        }) : jsonSchema;
-      return {
-        name: variantName,
-        schema: JSON.stringify(annotatedSchema),
-        level: match[0],
-        aggregateIdField: match[1],
-        mutationField: mutationField,
-        references: references,
-        allowedStates: allowedStates,
-        targetState: targetState,
-        apiExposed: apiExposed,
-        requiredAccess: requiredAccess,
-        ownerField: Owner$Reventless.fieldNamesOfProperties(properties)[0]
-      };
-    };
-    switch (v.type) {
-      case "string" :
-        let variantName = v.const;
-        if (variantName !== undefined) {
-          return mkDef(variantName, {});
-        } else {
+    case "object" :
+      let properties = v.properties;
+      return Stdlib_Option.flatMap(properties["TAG"], tagSchema => {
+        if (tagSchema.type !== "string") {
           return;
         }
-      case "object" :
-        let properties = v.properties;
-        return Stdlib_Option.flatMap(properties["TAG"], tagSchema => {
-          if (tagSchema.type !== "string") {
-            return;
-          }
-          let variantName = tagSchema.const;
-          if (variantName !== undefined) {
-            return mkDef(variantName, properties);
-          }
-        });
-      default:
-        return;
-    }
-  };
-  let extractCommandDefs = (isAggregate, mutationFieldFor, commandAuthorization, commandSchema) => {
-    if (commandSchema.type === "union") {
-      return Stdlib_Array.filterMap(commandSchema.anyOf, v => toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, v));
-    } else {
-      return Stdlib_Option.mapOr(toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, commandSchema), [], def => [def]);
-    }
+        let variantName = tagSchema.const;
+        if (variantName !== undefined) {
+          return mkDef(variantName, properties);
+        }
+      });
+    default:
+      return;
+  }
+}
+
+function extractCommandDefs(isAggregate, mutationFieldFor, commandAuthorization, commandSchema) {
+  if (commandSchema.type === "anyOf") {
+    return Stdlib_Array.filterMap(commandSchema.anyOf, v => toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, v));
+  } else {
+    return Stdlib_Option.mapOr(toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, commandSchema), [], def => [def]);
+  }
+}
+
+function visibilityTag(v) {
+  if (v === "Public") {
+    return;
+  } else {
+    return "Internal";
+  }
+}
+
+function queryableDefFromSpec(plugin, name, stateSchema, authorization, visibilityOpt, consumedEventTypesOpt, linkedWriteSideOpt, chapter) {
+  let visibility = visibilityOpt !== undefined ? visibilityOpt : "Public";
+  let consumedEventTypes = consumedEventTypesOpt !== undefined ? consumedEventTypesOpt : [];
+  let linkedWriteSide = linkedWriteSideOpt !== undefined ? linkedWriteSideOpt : [];
+  let qf = Api_Naming$ReventlessCore.queryFieldNamesForReadModel(plugin, name, undefined);
+  let label = labelFieldsFromStateSchema(name, stateSchema);
+  let keyField = GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField(name, stateSchema);
+  return {
+    name: name,
+    queryField: qf.listFieldName,
+    schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(stateSchema)),
+    consumedEventTypes: consumedEventTypes,
+    linkedWriteSide: linkedWriteSide,
+    labelField: label.field,
+    searchableFields: label.searchableFields,
+    labelFieldSource: labelFieldSourceToString(label.source),
+    lifecycleField: lifecycleFieldFromStateSchema(name, stateSchema),
+    ownerField: Owner$Reventless.fieldNames(stateSchema)[0],
+    retiredField: retiredFieldFromStateSchema(stateSchema),
+    retiredValues: retiredValuesFromStateSchema(stateSchema),
+    namedWhenRetired: namedWhenRetiredFromStateSchema(stateSchema),
+    visibility: visibilityTag(visibility),
+    chapter: chapter,
+    singleQueryField: qf.singleFieldName,
+    idField: Stdlib_Option.map(keyField, param => param[0]),
+    idFieldSource: Stdlib_Option.map(keyField, param => param[1]),
+    requiredAccess: accessKeysFor(authorization)
   };
+}
+
+function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionsOpt, extensionPointsOpt, componentChaptersOpt) {
+  let aggregates = aggregatesOpt !== undefined ? aggregatesOpt : [];
+  let readModels = readModelsOpt !== undefined ? readModelsOpt : [];
+  let stateViewSlices = stateViewSlicesOpt !== undefined ? stateViewSlicesOpt : [];
+  let stateChangeSlices = stateChangeSlicesOpt !== undefined ? stateChangeSlicesOpt : [];
+  let automationSlices = automationSlicesOpt !== undefined ? automationSlicesOpt : [];
+  let outboundTranslationSlices = outboundTranslationSlicesOpt !== undefined ? outboundTranslationSlicesOpt : [];
+  let inboundTranslationSlices = inboundTranslationSlicesOpt !== undefined ? inboundTranslationSlicesOpt : [];
+  let extensions = extensionsOpt !== undefined ? extensionsOpt : [];
+  let extensionPoints = extensionPointsOpt !== undefined ? extensionPointsOpt : [];
+  let componentChapters = componentChaptersOpt !== undefined ? componentChaptersOpt : ({});
+  let qualify = (prefix, names) => names.map(n => prefix + "." + n);
   let scsProduced = stateChangeSlices.map(SCS => [
     SCS.Spec.name,
     qualify(name, DcbTag$Reventless.extractVariantNames(SCS.Spec.eventSchema))
@@ -690,7 +722,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
         return [];
       }
     };
-    if (schema.type === "union") {
+    if (schema.type === "anyOf") {
       return schema.anyOf.flatMap(fromVariant);
     } else {
       return fromVariant(schema);
@@ -708,16 +740,13 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     }
   });
   let requiredStores = Belt_SetString.toArray(Belt_SetString.fromArray(requiredStoreDeclarations.map(d => d.store)));
+  let found = Capability_Inference$ReventlessCore.collisions(requiredStoreDeclarations);
+  if (found.length !== 0) {
+    Stdlib_JsError.throwWithMessage(name + `: two declared object stores look like one store misspelled.\n` + found.map(Capability_Inference$ReventlessCore.collisionMessage).join("\n"));
+  }
   storeDeclarationSites.forEach(param => {
     Capability_Inference$ReventlessCore.scanSchema(param[0], param[1]).forEach(w => log.warn("Plugin_Structure", undefined, Capability_Inference$ReventlessCore.message(w)));
   });
-  let visibilityTag = v => {
-    if (v === "Public") {
-      return;
-    } else {
-      return "Internal";
-    }
-  };
   let lifecycleStatesByView = {};
   let recordLifecycle = (entityName, stateSchema) => {
     let states = lifecycleStatesFromStateSchema(entityName, stateSchema);
@@ -916,7 +945,7 @@ export {
   isLabelShape,
   isLifecycleShape,
   conventionalLabelNames,
-  shapeOfItem,
+  shapeOfField,
   lifecycleFieldFromStateSchema,
   retiredFromStateSchema,
   retiredFieldFromStateSchema,
@@ -934,6 +963,14 @@ export {
   toEventDef,
   extractEventDefs,
   extractErrorDefs,
+  isCreateCommandName,
+  commandLevelAndId,
+  accessKeysFor,
+  annotateArgTypes,
+  toCommandDef,
+  extractCommandDefs,
+  visibilityTag,
+  queryableDefFromSpec,
   make,
 }
 /* log Not a pure module */

package/src/plugin/component/Plugin_SubscriptionSchema.res

@@ -44,7 +44,7 @@ let sourceCFields = (
   mutationEntries->Array.forEach(entry => {
     let schema = entry.commandSchema
     switch schema {
-    | Union({anyOf}) =>
+    | AnyOf({anyOf}) =>
       anyOf->Array.forEachWithIndex((_, i) => {
         let fieldName = entry.fieldNames->Array.get(i)->Option.getOr("")
         if fieldName->String.length > 0 {

package/src/plugin/component/Plugin_SubscriptionSchema.res.mjs

@@ -26,7 +26,7 @@ function sourceCFields(mutationEntries) {
         } else {
           return;
         }
-      case "union" :
+      case "anyOf" :
         schema.anyOf.forEach((param, i) => {
           let fieldName = Stdlib_Option.getOr(entry.fieldNames[i], "");
           if (fieldName.length > 0) {

package/src/plugin/component/SchemaWalker.res

@@ -10,7 +10,7 @@ open Plugin_BuiltHook
 
 // ---------------------------------------------------------------------------
 // Type description — maps a sury schema node to a human-readable string.
-// Optional fields in sury are Union({anyOf}) containing Null or Undefined.
+// Optional fields in sury are AnyOf({anyOf}) containing Null or Undefined.
 // ---------------------------------------------------------------------------
 let rec describeSchema = (schema: S.t<unknown>): string =>
   switch schema {
@@ -20,7 +20,7 @@ let rec describeSchema = (schema: S.t<unknown>): string =>
   | Boolean(_) => "bool"
   | BigInt(_) => "bigint"
   | Null(_) => "null"
-  | Union({anyOf}) =>
+  | AnyOf({anyOf}) =>
     // Nullable/optional field: Union of Null/Undefined + one real type.
     let nonNull = anyOf->Array.filter(v =>
       switch v {
@@ -58,7 +58,7 @@ let rec describeSchema = (schema: S.t<unknown>): string =>
 // (Union containing Null or Undefined).
 let isOptionalSchema = (schema: S.t<unknown>): bool =>
   switch schema {
-  | Union({anyOf}) =>
+  | AnyOf({anyOf}) =>
     anyOf->Array.some(v =>
       switch v {
       | Null(_) | Undefined(_) => true
@@ -112,11 +112,11 @@ let hashConstructors = (ctors: array<constructorSchema>): string => {
 // ---------------------------------------------------------------------------
 // TAG item helper — extracts the const string value from a TAG schema item.
 // ---------------------------------------------------------------------------
-let tagConstOf = (items: array<S.item>): option<string> =>
-  items
-  ->Array.find(item => item.location == "TAG")
-  ->Option.flatMap(item =>
-    switch item.schema {
+let tagConstOf = (properties: dict<S.t<unknown>>): option<string> =>
+  properties
+  ->Dict.get("TAG")
+  ->Option.flatMap(schema =>
+    switch schema {
     | String({const: ?Some(v)}) => Some(v)
     | _ => None
     }
@@ -135,7 +135,7 @@ let walkSchema = (typeName: string, schema: S.t<unknown>): typeSchema =>
       fields,
       structuralHash: hashFields(fields),
     }
-  | Union({anyOf}) =>
+  | AnyOf({anyOf}) =>
     // Check if this is a nullable scalar vs. a true variant union.
     let hasNullLike = anyOf->Array.some(v =>
       switch v {
@@ -150,8 +150,8 @@ let walkSchema = (typeName: string, schema: S.t<unknown>): typeSchema =>
       let constructors =
         anyOf->Array.filterMap(variantSchema =>
           switch variantSchema {
-          | Object({items, properties}) =>
-            tagConstOf(items)->Option.map(name => {
+          | Object({properties}) =>
+            tagConstOf(properties)->Option.map(name => {
               name,
               fields: extractFields(properties),
             })

package/src/plugin/component/SchemaWalker.res.mjs

@@ -25,7 +25,7 @@ function describeSchema(schema) {
     case "object" :
       let inner = Object.entries(schema.properties).filter(param => param[0] !== "TAG").toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])).map(param => param[0] + ":" + describeSchema(param[1])).join(",");
       return "{" + inner + "}";
-    case "union" :
+    case "anyOf" :
       let nonNull = schema.anyOf.filter(v => {
         switch (v.type) {
           case "null" :
@@ -47,7 +47,7 @@ function describeSchema(schema) {
 }
 
 function isOptionalSchema(schema) {
-  if (schema.type === "union") {
+  if (schema.type === "anyOf") {
     return schema.anyOf.some(v => {
       switch (v.type) {
         case "null" :
@@ -100,13 +100,12 @@ function hashConstructors(ctors) {
   });
 }
 
-function tagConstOf(items) {
-  return Stdlib_Option.flatMap(items.find(item => item.location === "TAG"), item => {
-    let match = item.schema;
-    if (match.type !== "string") {
+function tagConstOf(properties) {
+  return Stdlib_Option.flatMap(properties["TAG"], schema => {
+    if (schema.type !== "string") {
       return;
     }
-    let v = match.const;
+    let v = schema.const;
     if (v !== undefined) {
       return v;
     }
@@ -123,7 +122,7 @@ function walkSchema(typeName, schema) {
         fields: fields,
         structuralHash: hashFields(fields)
       };
-    case "union" :
+    case "anyOf" :
       let anyOf = schema.anyOf;
       let hasNullLike = anyOf.some(v => {
         switch (v.type) {
@@ -147,7 +146,7 @@ function walkSchema(typeName, schema) {
           return;
         }
         let properties = variantSchema.properties;
-        return Stdlib_Option.map(tagConstOf(variantSchema.items), name => ({
+        return Stdlib_Option.map(tagConstOf(properties), name => ({
           name: name,
           fields: extractFields(properties)
         }));