tinacms 0.66.9 → 0.66.10

package/dist/index.es.js

@@ -32,12 +32,13 @@ var __objRest = (source, exclude) => {
 import { useCMS, useBranchData, FormMetaPlugin, Form, GlobalFormPlugin, EventBus, Modal, ModalPopup, ModalHeader, ModalBody, ModalActions, Button, LoadingDots, useLocalStorage, TinaCMS, BranchSwitcherPlugin, BranchDataProvider, TinaProvider, Nav, LocalWarning, FormStatus, FormBuilder } from "@tinacms/toolkit";
 export * from "@tinacms/toolkit";
 import * as G from "graphql";
-import { TypeInfo, visit, visitWithTypeInfo, getNamedType, GraphQLObjectType, isLeafType, GraphQLUnionType, isScalarType, getIntrospectionQuery, buildClientSchema, print, parse } from "graphql";
+import { TypeInfo, visit, visitWithTypeInfo, getNamedType, GraphQLObjectType, isLeafType, GraphQLUnionType, isScalarType as isScalarType$1, getIntrospectionQuery, buildClientSchema, print, parse } from "graphql";
 import set from "lodash.set";
 import React, { useState, useCallback, useEffect, Fragment, useMemo } from "react";
 import { getIn, setIn } from "final-form";
-import * as yup from "yup";
+import { resolveForm, TinaSchema, addNamespaceToSchema } from "@tinacms/schema-tools";
 import gql$1 from "graphql-tag";
+import * as yup from "yup";
 import styled from "styled-components";
 import { setEditing, TinaDataContext, useEditState } from "@tinacms/sharedctx";
 import UrlPattern from "url-pattern";
@@ -287,7 +288,7 @@ const buildSelectionsFields = (fields, callback) => {
     const result = callback(fields);
     if (!result.continue) {
       if (fields.every((field) => {
-        return !isScalarType(getNamedType(field.type));
+        return !isScalarType$1(getNamedType(field.type));
       })) {
         return [
           {
@@ -300,7 +301,7 @@ const buildSelectionsFields = (fields, callback) => {
         ];
       }
       return buildSelectionsFields(result.filteredFields.filter((field) => {
-        if (isScalarType(getNamedType(field.type))) {
+        if (isScalarType$1(getNamedType(field.type))) {
           return true;
         }
         return false;
@@ -380,13 +381,15 @@ const createClient = ({
   clientId,
   isLocalClient = true,
   branch,
-  tinaioConfig
+  tinaioConfig,
+  schema
 }) => {
-  return isLocalClient ? new LocalClient() : new Client({
+  return isLocalClient ? new LocalClient({ schema }) : new Client({
     clientId: clientId || "",
     branch: branch || "main",
     tokenStorage: "LOCAL_STORAGE",
-    tinaioConfig
+    tinaioConfig,
+    schema
   });
 };
 function assertShape(value, yupSchema, errorMessage) {
@@ -515,11 +518,10 @@ function useGraphqlForms({
           values: yup2.object().required(),
           form: yup2.object().required()
         }), `Unable to build form shape for fields at ${queryName}`);
-        const formConfig = {
+        let formConfig = {};
+        const formCommon = {
           id: queryName,
-          label: result.form.label,
           initialValues: result.values,
-          fields: result.form.fields,
           reset: () => {
             setPendingReset(queryName);
           },
@@ -551,6 +553,29 @@ function useGraphqlForms({
             }
           }
         };
+        if (cms.api.tina.schema) {
+          const enrichedSchema = cms.api.tina.schema;
+          const collection = enrichedSchema.getCollection(result._internalSys.collection.name);
+          const template = enrichedSchema.getTemplateForData({
+            collection,
+            data: result.values
+          });
+          const formInfo = resolveForm({
+            collection,
+            basename: collection.name,
+            schema: enrichedSchema,
+            template
+          });
+          formConfig = __spreadValues({
+            label: formInfo.label,
+            fields: formInfo.fields
+          }, formCommon);
+        } else {
+          formConfig = __spreadValues({
+            label: result.form.label,
+            fields: result.form.fields
+          }, formCommon);
+        }
         const { createForm, createGlobalForm } = generateFormCreators(cms);
         const SKIPPED = "SKIPPED";
         let form;
@@ -722,100 +747,7 @@ const generateFormCreatorsUnstable = (cms, showInSidebar) => {
   };
   return { createForm, createGlobalForm };
 };
-const isNodeField = (type) => {
-  if (G.isUnionType(type)) {
-    return type.getTypes().every((type2) => {
-      return type2.getInterfaces().find((intfc) => intfc.name === "Node");
-    });
-  } else if (G.isObjectType(type)) {
-    return !!type.getInterfaces().find((intfc) => intfc.name === "Node");
-  } else if (G.isInterfaceType(type)) {
-    if (type.name === "Node") {
-      return true;
-    }
-  } else {
-    return false;
-  }
-};
-const isConnectionField = (type) => {
-  if (G.isObjectType(type)) {
-    return !!type.getInterfaces().find((intfc) => intfc.name === "Connection");
-  } else {
-    throw new Error(`Expected GraphQLObjectType for isConnectionField check`);
-  }
-};
-const getObjectField = (object, selectionNode) => {
-  return object.getFields()[selectionNode.name.value];
-};
-const getSelectedUnionType = (unionType, selectionNode) => {
-  return unionType.getTypes().find((type) => type.name === selectionNode.typeCondition.name.value);
-};
-function isListType(type) {
-  if (G.isListType(type)) {
-    return true;
-  } else if (G.isNonNullType(type)) {
-    if (G.isListType(type.ofType)) {
-      return true;
-    }
-  }
-  return false;
-}
-function ensureNodeField(field) {
-  if (!isNodeField(field)) {
-    throw new Error(`Expected field to implement Node interface`);
-  }
-}
-function ensureUnionType(type) {
-  if (!G.isUnionType(type)) {
-    throw new Error(`Expected type to be GraphQLUnionType`);
-  }
-}
-function ensureObjectType(type) {
-  if (!G.isObjectType(type)) {
-    console.log(type);
-    throw new Error(`Expected type to be GraphQLObjectType`);
-  }
-}
-function ensureOperationDefinition(type) {
-  if (type.kind !== "OperationDefinition") {
-    throw new Error(`Expected top-level definition to be an OperationDefinition node, ensure your query has been optimized before calling formify`);
-  }
-}
-function getNameAndAlias(fieldNode, list, isNode) {
-  return {
-    name: fieldNode.name.value,
-    alias: fieldNode.alias ? fieldNode.alias.value : fieldNode.name.value,
-    list: !!list,
-    isNode: !!isNode
-  };
-}
-const node = G.parse(`
- query Sample {
-   _internalSys: sys {
-     path
-     collection {
-       name
-     }
-   }
-   form
-   values
- }`);
-const metaFields = node.definitions[0].selectionSet.selections;
-const getRelativeBlueprint = (path) => {
-  let indexOfLastNode = 0;
-  path.forEach((item, i) => {
-    if (item.isNode) {
-      if (i === path.length - 1)
-        ;
-      else {
-        indexOfLastNode = i;
-      }
-    }
-  });
-  const documentBlueprintPath = path.slice(0, indexOfLastNode + 1);
-  return getBlueprintNamePath({ path: documentBlueprintPath });
-};
-const getIn2 = (state, path) => {
+const getValueForBlueprint = (state, path) => {
   const pathArray = path.split(".");
   let latest = state;
   pathArray.every((item, index) => {
@@ -825,7 +757,7 @@ const getIn2 = (state, path) => {
         const next = [];
         if (Array.isArray(latest)) {
           latest.forEach((latest2, index2) => {
-            const res = getIn2(latest2, restOfItems.join("."));
+            const res = getValueForBlueprint(latest2, restOfItems.join("."));
             next.push(res);
           });
         } else {
@@ -892,9 +824,8 @@ const buildForm = (doc, cms, formify2, showInSidebar = false, onSubmit) => {
   if (skipped)
     return;
   const id = doc._internalSys.path;
-  const formConfig = __spreadProps(__spreadValues({
-    id
-  }, doc.form), {
+  const formCommon = {
+    id,
     label: doc.form.label,
     initialValues: doc.values,
     onSubmit: async (payload) => {
@@ -924,7 +855,31 @@ const buildForm = (doc, cms, formify2, showInSidebar = false, onSubmit) => {
         cms.alerts.error("There was a problem saving your document");
       }
     }
-  });
+  };
+  let formConfig = {};
+  if (cms.api.tina.schema) {
+    const enrichedSchema = cms.api.tina.schema;
+    const collection = enrichedSchema.getCollection(doc._internalSys.collection.name);
+    const template = enrichedSchema.getTemplateForData({
+      collection,
+      data: doc.values
+    });
+    const formInfo = resolveForm({
+      collection,
+      basename: collection.name,
+      schema: enrichedSchema,
+      template
+    });
+    formConfig = __spreadValues({
+      label: formInfo.label,
+      fields: formInfo.fields
+    }, formCommon);
+  } else {
+    formConfig = __spreadValues({
+      label: doc.form.label,
+      fields: doc.form.fields
+    }, formCommon);
+  }
   if (formify2) {
     form = formify2({
       formConfig,
@@ -970,19 +925,6 @@ const sequential = async (items, callback) => {
   }
   return accum;
 };
-const getBlueprintId = (path) => {
-  const namePath = [];
-  const aliasPath = [];
-  path.forEach((p) => {
-    namePath.push(p.name);
-    aliasPath.push(p.alias);
-    if (p.list) {
-      namePath.push("[]");
-      aliasPath.push("[]");
-    }
-  });
-  return namePath.join(".");
-};
 const getFormNodesStartingWith = (string, state) => {
   return state.formNodes.filter((subFormNode) => {
     return subFormNode.documentBlueprintId.startsWith(string);
@@ -998,44 +940,6 @@ const getFormNodesForField = (fieldBlueprint, formNode, event, state) => {
   const existing = getIn(state.data, pathToChange);
   return { pathToChange, formNodes, eventLocation, existing };
 };
-const matchLocation = (eventLocation, formNode) => {
-  return eventLocation.every((item, index) => item === formNode.location[index]);
-};
-const bumpLocation = (location) => {
-  return location.map((item, index) => {
-    if (index === location.length - 1) {
-      return item + 1;
-    }
-    return item;
-  });
-};
-const maybeLowerLocation = (location, at) => {
-  return location.map((item, index) => {
-    if (index === location.length - 1) {
-      return item < at ? item : item - 1;
-    }
-    return item;
-  });
-};
-const matchesAt = (location, at) => {
-  let matches = false;
-  location.map((item, index) => {
-    if (index === location.length - 1) {
-      if (item === at) {
-        matches = true;
-      }
-    }
-  });
-  return matches;
-};
-const swapLocation = (location, mapping) => {
-  return location.map((item, index) => {
-    if (index === location.length - 1) {
-      return mapping[item];
-    }
-    return item;
-  });
-};
 const getBlueprintAliasPath = (blueprint) => {
   const namePath = [];
   const aliasPath = [];
@@ -1051,22 +955,56 @@ const getBlueprintAliasPath = (blueprint) => {
 };
 const getBlueprintFieldsForEvent = (blueprint, event) => {
   return blueprint.fields.filter((fbp) => {
-    return getBlueprintNamePath(fbp) === getEventPath(event, blueprint);
+    if (getBlueprintNamePath(fbp) === getEventPath(event, blueprint)) {
+      return true;
+    }
+  }).filter((fbp) => {
+    return filterFieldBlueprintsByParentTypename(fbp, event.field.data.tinaField.parentTypename);
+  });
+};
+const filterFieldBlueprintsByParentTypename = (fbp, typename) => {
+  let lastDisambiguator;
+  fbp.path.forEach((path) => {
+    if (path.parentTypename) {
+      lastDisambiguator = path.parentTypename;
+    }
   });
+  if (lastDisambiguator) {
+    return typename === lastDisambiguator;
+  } else {
+    return true;
+  }
 };
-const getBlueprintNamePath = (blueprint) => {
+const getBlueprintNamePath = (blueprint, disambiguator) => {
   const namePath = [];
-  const aliasPath = [];
   blueprint.path.forEach((p) => {
+    if (disambiguator) {
+      if (p.parentTypename) {
+        namePath.push(p.parentTypename);
+      }
+    }
     namePath.push(p.name);
-    aliasPath.push(p.alias);
     if (p.list) {
       namePath.push("[]");
-      aliasPath.push("[]");
     }
   });
   return namePath.join(".");
 };
+const getEventPath = (event, blueprint) => {
+  const stringArray = event.field.name.split(".");
+  const eventPath = stringArray.map((item) => {
+    if (isNaN(Number(item))) {
+      return item;
+    }
+    return `[]`;
+  }).join(".");
+  const items = [blueprint.id, DATA_NODE_NAME$1, eventPath];
+  const isList = event.field.data.tinaField.list;
+  if (isList && !eventPath.endsWith("[]")) {
+    items.push(`[]`);
+  }
+  return items.join(".");
+};
 const stripIndices = (string) => {
   const accum = [];
   const stringArray = string.split(".");
@@ -1088,20 +1026,21 @@ const replaceRealNum = (string) => {
     return "[]";
   }).join(".");
 };
+const getMatchName = ({ field, prefix, blueprint }) => {
+  const fieldName = field.list ? `${field.name}.[]` : field.name;
+  const blueprintName = getBlueprintNamePath(blueprint);
+  const extra = [];
+  if (prefix) {
+    extra.push(prefix);
+  }
+  const matchName = [blueprintName, DATA_NODE_NAME$1, ...extra, fieldName].join(".");
+  return { matchName, fieldName };
+};
 const getFormNodesFromEvent = (state, event) => {
   const formNodes = state.formNodes.filter((formNode) => formNode.documentFormId === event.formId);
   return formNodes;
 };
 const DATA_NODE_NAME$1 = "data";
-const getEventPath = (event, blueprint) => {
-  const eventPath = replaceRealNum(event.field.name);
-  const items = [blueprint.id, DATA_NODE_NAME$1, eventPath];
-  const isList = event.field.data.tinaField.list;
-  if (isList && !eventPath.endsWith("[]")) {
-    items.push("[]");
-  }
-  return items.join(".");
-};
 const printEvent = (event) => {
   var _a, _b;
   return {
@@ -1170,17 +1109,43 @@ const getMoveMapping = (existing, from, to) => {
   }
   return newOrderObject;
 };
-const getPathsToChange = (event, state) => {
-  const pathsToChange = [];
-  const formNodes = getFormNodesFromEvent(state, event);
-  formNodes.forEach((formNode) => {
-    const blueprint = getFormNodeBlueprint(formNode, state);
-    getBlueprintFieldsForEvent(blueprint, event).forEach((fieldBlueprint) => {
-      const pathToChange = getPathToChange(fieldBlueprint, formNode, event);
-      pathsToChange.push({ pathToChange, formNode });
-    });
+const matchLocation = (eventLocation, formNode) => {
+  return eventLocation.every((item, index) => item === formNode.location[index]);
+};
+const bumpLocation = (location) => {
+  return location.map((item, index) => {
+    if (index === location.length - 1) {
+      return item + 1;
+    }
+    return item;
+  });
+};
+const maybeLowerLocation = (location, at) => {
+  return location.map((item, index) => {
+    if (index === location.length - 1) {
+      return item < at ? item : item - 1;
+    }
+    return item;
+  });
+};
+const matchesAt = (location, at) => {
+  let matches = false;
+  location.map((item, index) => {
+    if (index === location.length - 1) {
+      if (item === at) {
+        matches = true;
+      }
+    }
+  });
+  return matches;
+};
+const swapLocation = (location, mapping) => {
+  return location.map((item, index) => {
+    if (index === location.length - 1) {
+      return mapping[item];
+    }
+    return item;
   });
-  return pathsToChange;
 };
 const getSubFields = (changeSet) => {
   var _a;
@@ -1191,6 +1156,133 @@ const getSubFields = (changeSet) => {
   }
   return { fields, __typename };
 };
+const isFormifiableDocument = (t) => {
+  const type = G.getNamedType(t);
+  if (G.isUnionType(type)) {
+    return type.getTypes().every((type2) => {
+      return type2.getInterfaces().find((intfc) => intfc.name === "Node");
+    });
+  } else if (G.isObjectType(type)) {
+    return !!type.getInterfaces().find((intfc) => intfc.name === "Node");
+  } else {
+    return false;
+  }
+};
+const isScalarType = (t) => {
+  const namedType = G.getNamedType(t);
+  return G.isScalarType(namedType);
+};
+const isConnectionField = (t) => {
+  const type = G.getNamedType(t);
+  if (G.isObjectType(type)) {
+    return !!type.getInterfaces().find((intfc) => intfc.name === "Connection");
+  } else {
+    throw new Error(`Expected GraphQLObjectType for isConnectionField check`);
+  }
+};
+const getObjectField = (object, selectionNode) => {
+  const namedType = G.getNamedType(object);
+  ensureObjectOrInterfaceType(namedType);
+  return namedType.getFields()[selectionNode.name.value];
+};
+const getSelectedUnionType = (unionType, selectionNode) => {
+  const namedType = G.getNamedType(unionType);
+  if (!G.isUnionType(namedType)) {
+    return;
+  }
+  const types = namedType.getTypes();
+  const typeCondition = selectionNode.typeCondition.name.value;
+  let intfc;
+  types.forEach((type) => {
+    intfc = type.getInterfaces().find((intfc2) => intfc2.name === typeCondition);
+  });
+  if (intfc) {
+    return intfc;
+  }
+  return namedType.getTypes().find((type) => type.name === typeCondition);
+};
+function isListType(type) {
+  if (G.isListType(type)) {
+    return true;
+  } else if (G.isNonNullType(type)) {
+    if (G.isListType(type.ofType)) {
+      return true;
+    }
+  }
+  return false;
+}
+function ensureObjectOrInterfaceType(type) {
+  if (G.isInterfaceType(type) || G.isObjectType(type))
+    ;
+  else {
+    console.log("Expected type to be GraphQLObjectType or GraphQLInterfaceType", type);
+    throw new Error(`Expected type to be GraphQLObjectType or GraphQLInterfaceType`);
+  }
+}
+function ensureOperationDefinition(type) {
+  if (type.kind !== "OperationDefinition") {
+    throw new Error(`Expected top-level definition to be an OperationDefinition node, ensure your query has been optimized before calling formify`);
+  }
+}
+function buildPath({
+  fieldNode,
+  type,
+  parentTypename,
+  path
+}) {
+  const p = path || [];
+  const list = isListType(type);
+  const isNode = isFormifiableDocument(type);
+  return [
+    ...p,
+    {
+      name: fieldNode.name.value,
+      alias: fieldNode.alias ? fieldNode.alias.value : fieldNode.name.value,
+      parentTypename,
+      list: !!list,
+      isNode: !!isNode
+    }
+  ];
+}
+const node = G.parse(`
+ query Sample {
+   _internalSys: sys {
+     path
+     collection {
+       name
+     }
+   }
+   form
+   values
+ }`);
+const metaFields = node.definitions[0].selectionSet.selections;
+const getRelativeBlueprint = (path) => {
+  let indexOfLastNode = 0;
+  path.forEach((item, i) => {
+    if (item.isNode) {
+      if (i === path.length - 1)
+        ;
+      else {
+        indexOfLastNode = i;
+      }
+    }
+  });
+  const documentBlueprintPath = path.slice(0, indexOfLastNode + 1);
+  return getBlueprintNamePath({ path: documentBlueprintPath });
+};
+const getBlueprintId = (path) => {
+  const namePath = [];
+  const aliasPath = [];
+  path.forEach((p) => {
+    namePath.push(p.name);
+    aliasPath.push(p.alias);
+    if (p.list) {
+      namePath.push("[]");
+      aliasPath.push("[]");
+    }
+  });
+  return namePath.join(".");
+};
 const NOOP = "This is either an error or is not yet supported";
 const UNEXPECTED = "Formify encountered an unexpected error, please contact support";
 const EDGES_NODE_NAME = "edges";
@@ -1223,11 +1315,10 @@ const formify = async ({
   const optimizedQuery = await getOptimizedQuery(documentNodeWithName);
   const typeInfo = new G.TypeInfo(schema);
   const formifyConnection = ({
-    namedFieldType,
+    parentType,
     selectionNode,
     path
   }) => {
-    ensureObjectType(namedFieldType);
     return __spreadProps(__spreadValues({}, selectionNode), {
       selectionSet: {
         kind: "SelectionSet",
@@ -1235,13 +1326,12 @@ const formify = async ({
           switch (selectionNode2.kind) {
             case "Field":
               if (selectionNode2.name.value === EDGES_NODE_NAME) {
-                const edgeField = namedFieldType.getFields()[EDGES_NODE_NAME];
-                const edgeType = G.getNamedType(edgeField.type);
-                ensureObjectType(edgeType);
-                const path2 = [
-                  ...path,
-                  getNameAndAlias(selectionNode2, true, false)
-                ];
+                const edgeField = getObjectField(parentType, selectionNode2);
+                const edgesPath = buildPath({
+                  fieldNode: selectionNode2,
+                  type: edgeField.type,
+                  path
+                });
                 return __spreadProps(__spreadValues({}, selectionNode2), {
                   selectionSet: {
                     kind: "SelectionSet",
@@ -1249,15 +1339,15 @@ const formify = async ({
                       switch (subSelectionNode.kind) {
                         case "Field":
                           if (subSelectionNode.name.value === NODE_NAME) {
-                            const nodeField = edgeType.getFields()[NODE_NAME];
-                            const path3 = [
-                              ...path2,
-                              getNameAndAlias(subSelectionNode, false, true)
-                            ];
-                            return formifyNode({
-                              fieldOrInlineFragmentNode: subSelectionNode,
+                            const nodeField = getObjectField(edgeField.type, subSelectionNode);
+                            return formifyFieldNodeDocument({
+                              fieldNode: subSelectionNode,
                               type: nodeField.type,
-                              path: path3,
+                              path: buildPath({
+                                fieldNode: subSelectionNode,
+                                type: nodeField.type,
+                                path: edgesPath
+                              }),
                               showInSidebar: false
                             });
                           } else {
@@ -1278,28 +1368,48 @@ const formify = async ({
       }
     });
   };
-  function formifyNode({
-    fieldOrInlineFragmentNode,
+  function formifyInlineFragmentDocument({
+    inlineFragmentNode,
+    type,
+    path,
+    showInSidebar = false
+  }) {
+    return formifyDocument({
+      selection: inlineFragmentNode,
+      type,
+      path,
+      showInSidebar
+    });
+  }
+  function formifyFieldNodeDocument({
+    fieldNode,
+    type,
+    path,
+    showInSidebar = false
+  }) {
+    return formifyDocument({ selection: fieldNode, type, path, showInSidebar });
+  }
+  function formifyDocument({
+    selection,
     type,
     path,
     showInSidebar = false
   }) {
     let extraFields = [];
-    const namedType = G.getNamedType(type);
     let hasDataJSONField = false;
     let hasValuesField = false;
     let shouldFormify = false;
-    fieldOrInlineFragmentNode.selectionSet.selections.forEach((selection) => {
-      if (selection.kind === "Field") {
-        if (selection.name.value === "dataJSON") {
+    selection.selectionSet.selections.forEach((selection2) => {
+      if (selection2.kind === "Field") {
+        if (selection2.name.value === "dataJSON") {
           shouldFormify = true;
           hasDataJSONField = true;
         }
-        if (selection.name.value === "values") {
+        if (selection2.name.value === "values") {
           shouldFormify = true;
           hasValuesField = true;
         }
-        if (selection.name.value === "data") {
+        if (selection2.name.value === "data") {
           shouldFormify = true;
         }
       }
@@ -1308,7 +1418,7 @@ const formify = async ({
       blueprints.push({
         id: getBlueprintId(path),
         path,
-        selection: fieldOrInlineFragmentNode,
+        selection,
         fields: [],
         showInSidebar,
         hasDataJSONField,
@@ -1316,71 +1426,58 @@ const formify = async ({
       });
       extraFields = metaFields;
     }
-    const formifiedNode = __spreadProps(__spreadValues({}, fieldOrInlineFragmentNode), {
+    return __spreadProps(__spreadValues({}, selection), {
       selectionSet: {
         kind: "SelectionSet",
         selections: [
-          ...fieldOrInlineFragmentNode.selectionSet.selections.map((selectionNode) => {
+          ...selection.selectionSet.selections.map((selectionNode) => {
             switch (selectionNode.kind) {
-              case "InlineFragment":
+              case "InlineFragment": {
+                const namedType = G.getNamedType(type);
                 if (G.isInterfaceType(namedType)) {
-                  const subType2 = schema.getImplementations(namedType).objects.find((item) => item.name === selectionNode.typeCondition.name.value);
-                  return formifyNode({
-                    fieldOrInlineFragmentNode: selectionNode,
-                    type: subType2,
+                  const subType = schema.getImplementations(namedType).objects.find((item) => item.name === selectionNode.typeCondition.name.value);
+                  return formifyInlineFragmentDocument({
+                    inlineFragmentNode: selectionNode,
+                    type: subType,
                     path,
-                    showInSidebar: false
+                    showInSidebar: true
                   });
                 }
-                ensureUnionType(namedType);
-                const subType = getSelectedUnionType(namedType, selectionNode);
-                return formifyNode({
-                  fieldOrInlineFragmentNode: selectionNode,
-                  type: subType,
-                  path,
-                  showInSidebar
+                return formifyInlineFragmentNode({
+                  inlineFragmentNode: selectionNode,
+                  parentType: type,
+                  path
                 });
-              case "Field":
+              }
+              case "Field": {
                 if (selectionNode.name.value === DATA_NODE_NAME) {
-                  const path2 = [
-                    ...path,
-                    getNameAndAlias(selectionNode, false, false)
-                  ];
-                  if (G.isObjectType(namedType)) {
-                    const field = getObjectField(namedType, selectionNode);
-                    const namedSubType = G.getNamedType(field.type);
-                    ensureObjectType(namedSubType);
-                    return __spreadProps(__spreadValues({}, selectionNode), {
-                      selectionSet: {
-                        kind: "SelectionSet",
-                        selections: [
-                          ...selectionNode.selectionSet.selections.map((subSelectionNode) => {
-                            switch (subSelectionNode.kind) {
-                              case "Field":
-                                const subSelectionField = getObjectField(namedSubType, subSelectionNode);
-                                if (!subSelectionField) {
-                                  return subSelectionNode;
-                                }
-                                const subSelectionType = G.getNamedType(subSelectionField.type);
-                                return formifyField({
-                                  fieldNode: subSelectionNode,
-                                  parentType: field.type,
-                                  path: [
-                                    ...path2,
-                                    getNameAndAlias(subSelectionNode, isListType(subSelectionField.type), isNodeField(subSelectionType))
-                                  ]
-                                });
-                              default:
-                                throw new FormifyError("UNEXPECTED", `selection ${subSelectionNode.kind}`);
-                            }
-                          })
-                        ]
-                      }
-                    });
-                  }
-                  throw new FormifyError("UNEXPECTED");
+                  const field = getObjectField(type, selectionNode);
+                  return __spreadProps(__spreadValues({}, selectionNode), {
+                    selectionSet: {
+                      kind: "SelectionSet",
+                      selections: [
+                        ...selectionNode.selectionSet.selections.map((subSelectionNode) => {
+                          switch (subSelectionNode.kind) {
+                            case "Field":
+                              return formifyFieldNode({
+                                fieldNode: subSelectionNode,
+                                parentType: field.type,
+                                path: buildPath({
+                                  fieldNode: selectionNode,
+                                  type: field.type,
+                                  path
+                                })
+                              });
+                            default:
+                              throw new FormifyError("UNEXPECTED", `selection ${subSelectionNode.kind}`);
+                          }
+                        })
+                      ]
+                    }
+                  });
                 }
                 return selectionNode;
+              }
               default:
                 throw new FormifyError("UNEXPECTED");
             }
@@ -1389,32 +1486,35 @@ const formify = async ({
         ]
       }
     });
-    return formifiedNode;
   }
-  const formifyField = ({
+  const formifyFieldNode = ({
     fieldNode,
     parentType,
     path
   }) => {
-    const namedParentType = G.getNamedType(parentType);
-    ensureObjectType(namedParentType);
-    const field = getObjectField(namedParentType, fieldNode);
+    if (fieldNode.name.value === "__typename") {
+      return fieldNode;
+    }
+    const field = getObjectField(parentType, fieldNode);
     if (!field) {
-      if (fieldNode.name.value === "__typename") {
-        return fieldNode;
-      } else {
-        throw new FormifyError("UNEXPECTED", `field with no associated type ${fieldNode.name.value}`);
-      }
+      return fieldNode;
     }
-    const namedType = G.getNamedType(field.type);
-    const fieldBlueprint = {
-      id: getBlueprintId([...path]),
-      documentBlueprintId: getRelativeBlueprint(path),
-      path: [...path]
-    };
     const blueprint = blueprints.find((blueprint2) => blueprint2.id === getRelativeBlueprint(path));
-    blueprint.fields.push(fieldBlueprint);
-    if (G.isScalarType(namedType)) {
+    if (!blueprint) {
+      return fieldNode;
+    }
+    const fieldPath = buildPath({
+      fieldNode,
+      type: field.type,
+      parentTypename: G.getNamedType(parentType).name,
+      path
+    });
+    blueprint.fields.push({
+      id: getBlueprintId(fieldPath),
+      documentBlueprintId: blueprint.id,
+      path: fieldPath
+    });
+    if (isScalarType(field.type)) {
       return fieldNode;
     }
     return __spreadProps(__spreadValues({}, fieldNode), {
@@ -1423,121 +1523,20 @@ const formify = async ({
         selections: [
           ...fieldNode.selectionSet.selections.map((selectionNode) => {
             switch (selectionNode.kind) {
-              case "Field":
-                if (selectionNode.name.value === "__typename") {
-                  return selectionNode;
-                }
-                ensureObjectType(namedType);
-                const subField = getObjectField(namedType, selectionNode);
-                if (!subField) {
-                  return fieldNode;
-                }
-                if (G.isScalarType(G.getNamedType(subField.type))) {
-                  const newPath2 = [
-                    ...path,
-                    getNameAndAlias(selectionNode, isListType(subField.type), false)
-                  ];
-                  const fieldBlueprint3 = {
-                    id: getBlueprintId(newPath2),
-                    documentBlueprintId: getRelativeBlueprint(newPath2),
-                    path: newPath2
-                  };
-                  const blueprint3 = blueprints.find((blueprint4) => blueprint4.id === getRelativeBlueprint(path));
-                  blueprint3.fields.push(fieldBlueprint3);
-                  return selectionNode;
-                }
-                const subFieldType = subField.type;
-                const namedSubFieldType = G.getNamedType(subFieldType);
-                const newPath = [
-                  ...path,
-                  getNameAndAlias(selectionNode, isListType(subFieldType), isNodeField(namedSubFieldType))
-                ];
-                const fieldBlueprint2 = {
-                  id: getBlueprintId(newPath),
-                  documentBlueprintId: getRelativeBlueprint(newPath),
-                  path: newPath
-                };
-                const blueprint2 = blueprints.find((blueprint3) => blueprint3.id === getRelativeBlueprint(path));
-                blueprint2.fields.push(fieldBlueprint2);
-                return __spreadProps(__spreadValues({}, selectionNode), {
-                  selectionSet: {
-                    kind: "SelectionSet",
-                    selections: selectionNode.selectionSet.selections.map((subSelectionNode) => {
-                      switch (subSelectionNode.kind) {
-                        case "Field":
-                          if (subSelectionNode.name.value === "__typename") {
-                            return subSelectionNode;
-                          }
-                          ensureObjectType(namedSubFieldType);
-                          const subField1 = getObjectField(namedSubFieldType, subSelectionNode);
-                          const subType1 = subField1.type;
-                          const namedSubType2 = G.getNamedType(subType1);
-                          return formifyField({
-                            fieldNode: subSelectionNode,
-                            parentType: subFieldType,
-                            path: [
-                              ...path,
-                              getNameAndAlias(subSelectionNode, isListType(subType1), isNodeField(namedSubType2))
-                            ]
-                          });
-                        case "InlineFragment":
-                          const subNamedType = G.getNamedType(subField.type);
-                          ensureNodeField(subNamedType);
-                          ensureUnionType(subNamedType);
-                          const subType2 = getSelectedUnionType(subNamedType, subSelectionNode);
-                          const newPath2 = [
-                            ...path,
-                            getNameAndAlias(selectionNode, isListType(subField.type), true)
-                          ];
-                          return formifyNode({
-                            fieldOrInlineFragmentNode: subSelectionNode,
-                            type: subType2,
-                            path: newPath2,
-                            showInSidebar: false
-                          });
-                        default:
-                          throw new FormifyError("UNEXPECTED", `selection ${subSelectionNode.kind}`);
-                      }
-                    })
-                  }
+              case "Field": {
+                return formifyFieldNode({
+                  fieldNode: selectionNode,
+                  parentType: field.type,
+                  path: fieldPath
                 });
-              case "InlineFragment":
-                ensureUnionType(namedType);
-                if (isNodeField(namedType)) {
-                  const parentType2 = getSelectedUnionType(namedType, selectionNode);
-                  return formifyNode({
-                    fieldOrInlineFragmentNode: selectionNode,
-                    type: parentType2,
-                    path,
-                    showInSidebar: false
-                  });
-                }
-                const subType = getSelectedUnionType(namedType, selectionNode);
-                const namedSubType = G.getNamedType(subType);
-                return __spreadProps(__spreadValues({}, selectionNode), {
-                  selectionSet: {
-                    kind: "SelectionSet",
-                    selections: selectionNode.selectionSet.selections.map((subSelectionNode) => {
-                      switch (subSelectionNode.kind) {
-                        case "Field":
-                          ensureObjectType(namedSubType);
-                          const subField2 = getObjectField(namedSubType, subSelectionNode);
-                          const subType2 = subField2.type;
-                          const namedSubType2 = G.getNamedType(subType2);
-                          return formifyField({
-                            fieldNode: subSelectionNode,
-                            parentType: subType,
-                            path: [
-                              ...path,
-                              getNameAndAlias(subSelectionNode, isListType(subType2), isNodeField(namedSubType2))
-                            ]
-                          });
-                        default:
-                          throw new FormifyError("UNEXPECTED", `selection ${subSelectionNode.kind}`);
-                      }
-                    })
-                  }
+              }
+              case "InlineFragment": {
+                return formifyInlineFragmentNode({
+                  inlineFragmentNode: selectionNode,
+                  parentType: field.type,
+                  path: fieldPath
                 });
+              }
               default:
                 throw new FormifyError("UNEXPECTED", `selection ${selectionNode.kind}`);
             }
@@ -1546,43 +1545,77 @@ const formify = async ({
       }
     });
   };
+  const formifyInlineFragmentNode = ({
+    inlineFragmentNode,
+    parentType,
+    path
+  }) => {
+    const type = getSelectedUnionType(parentType, inlineFragmentNode);
+    if (!type) {
+      return inlineFragmentNode;
+    }
+    if (isFormifiableDocument(type)) {
+      return formifyInlineFragmentDocument({
+        inlineFragmentNode,
+        type,
+        path,
+        showInSidebar: false
+      });
+    }
+    return __spreadProps(__spreadValues({}, inlineFragmentNode), {
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: inlineFragmentNode.selectionSet.selections.map((selectionNode) => {
+          switch (selectionNode.kind) {
+            case "Field":
+              return formifyFieldNode({
+                fieldNode: selectionNode,
+                parentType: type,
+                path
+              });
+            default:
+              throw new FormifyError("UNEXPECTED", `selection ${selectionNode.kind}`);
+          }
+        })
+      }
+    });
+  };
   const formifiedQuery = {
     kind: "Document",
     definitions: optimizedQuery.definitions.map((definition) => {
       typeInfo.enter(definition);
       ensureOperationDefinition(definition);
-      const type = typeInfo.getType();
-      const namedType = G.getNamedType(type);
-      ensureObjectType(namedType);
+      const parentType = typeInfo.getType();
       return __spreadProps(__spreadValues({}, definition), {
         selectionSet: {
           kind: "SelectionSet",
           selections: definition.selectionSet.selections.map((selectionNode) => {
             switch (selectionNode.kind) {
               case "Field":
-                const parentType = type;
-                const namedParentType = G.getNamedType(parentType);
-                ensureObjectType(namedParentType);
-                const field = getObjectField(namedParentType, selectionNode);
-                const namedFieldType = G.getNamedType(field.type);
-                if (isNodeField(namedFieldType)) {
-                  return formifyNode({
-                    fieldOrInlineFragmentNode: selectionNode,
+                const field = getObjectField(parentType, selectionNode);
+                const path = buildPath({
+                  fieldNode: selectionNode,
+                  type: field.type
+                });
+                if (isFormifiableDocument(field.type)) {
+                  return formifyFieldNodeDocument({
+                    fieldNode: selectionNode,
                     type: field.type,
-                    path: [getNameAndAlias(selectionNode, false, true)],
+                    path,
                     showInSidebar: true
                   });
-                } else if (isConnectionField(namedFieldType)) {
+                } else if (isConnectionField(field.type)) {
                   return formifyConnection({
-                    namedFieldType,
+                    parentType: field.type,
                     selectionNode,
-                    path: [getNameAndAlias(selectionNode, false, false)]
+                    path
                   });
                 }
                 if (selectionNode.name.value === COLLECTION_FIELD_NAME || selectionNode.name.value === COLLECTIONS_FIELD_NAME) {
-                  const path = [
-                    getNameAndAlias(selectionNode, false, false)
-                  ];
+                  const path2 = buildPath({
+                    fieldNode: selectionNode,
+                    type: field.type
+                  });
                   return __spreadProps(__spreadValues({}, selectionNode), {
                     selectionSet: {
                       kind: "SelectionSet",
@@ -1590,16 +1623,15 @@ const formify = async ({
                         switch (subSelectionNode.kind) {
                           case "Field":
                             if (subSelectionNode.name.value === COLLECTIONS_DOCUMENTS_NAME) {
-                              ensureObjectType(namedFieldType);
-                              const n = namedFieldType.getFields()[COLLECTIONS_DOCUMENTS_NAME];
-                              const docType = G.getNamedType(n.type);
+                              const subField = getObjectField(field.type, subSelectionNode);
                               return formifyConnection({
-                                namedFieldType: docType,
+                                parentType: subField.type,
                                 selectionNode: subSelectionNode,
-                                path: [
-                                  ...path,
-                                  getNameAndAlias(subSelectionNode, isListType(docType), isNodeField(docType))
-                                ]
+                                path: buildPath({
+                                  fieldNode: subSelectionNode,
+                                  type: subField.type,
+                                  path: path2
+                                })
                               });
                             }
                             return subSelectionNode;
@@ -1639,9 +1671,27 @@ class FormifyError extends Error {
     this.name = "FormifyError";
   }
 }
+const defaultState = {
+  status: "idle",
+  schema: void 0,
+  query: null,
+  queryString: null,
+  data: {},
+  changeSets: [],
+  count: 0,
+  blueprints: [],
+  formNodes: [],
+  documentForms: []
+};
 function reducer(state, action) {
   var _a, _b, _c, _d;
   switch (action.type) {
+    case "start":
+      return __spreadProps(__spreadValues(__spreadValues({}, state), defaultState), {
+        query: action.value.query ? G.parse(action.value.query) : null,
+        queryString: action.value.query,
+        status: "initialized"
+      });
     case "addDocumentBlueprints":
       return __spreadProps(__spreadValues({}, state), {
         status: "formified",
@@ -1696,16 +1746,21 @@ function reducer(state, action) {
         }
         if (event.mutationType.type === "change") {
           if (!action.value.form) {
-            getPathsToChange(event, state).forEach(({ formNode: formNode2, pathToChange }) => {
+            getBlueprintFieldsForEvent(blueprint, event).forEach((fieldBlueprint) => {
+              const { pathToChange } = getFormNodesForField(fieldBlueprint, formNode, event, state);
               changeSets.push(__spreadValues({
                 path: pathToChange
-              }, buildChangeSet(event, formNode2)));
+              }, buildChangeSet(event, formNode)));
             });
           }
         } else if (event.mutationType.type === "referenceChange") {
           getBlueprintFieldsForEvent(blueprint, event).forEach((fieldBlueprint) => {
-            const { pathToChange, formNodes, eventLocation } = getFormNodesForField(fieldBlueprint, formNode, event, state);
-            if (action.value.form) {
+            const {
+              pathToChange,
+              formNodes: subFormNodes,
+              eventLocation
+            } = getFormNodesForField(fieldBlueprint, formNode, event, state);
+            if (action.value.form && state.blueprints.find((blueprint2) => blueprint2.id === fieldBlueprint.id)) {
               const newFormNode = {
                 documentBlueprintId: fieldBlueprint.id,
                 documentFormId: action.value.form.id,
@@ -1716,8 +1771,15 @@ function reducer(state, action) {
                 path: pathToChange
               }, buildChangeSet(event, newFormNode)));
             }
-            formNodes.forEach((subFormNode) => {
+            subFormNodes.forEach((subFormNode) => {
               if (matchLocation(eventLocation, subFormNode)) {
+                if (!action.value.form) {
+                  changeSets.push(__spreadProps(__spreadValues({
+                    path: pathToChange
+                  }, buildChangeSet(event, subFormNode)), {
+                    value: null
+                  }));
+                }
                 formNodesToReplace.push(subFormNode);
               }
             });
@@ -1870,7 +1932,7 @@ const useFormify = ({
 }) => {
   const formIds = React.useRef([]);
   const [state, dispatch] = React.useReducer(reducer, {
-    status: "initialized",
+    status: "idle",
     schema: void 0,
     query: query ? G.parse(query) : null,
     queryString: query,
@@ -1881,6 +1943,17 @@ const useFormify = ({
     formNodes: [],
     documentForms: []
   });
+  React.useEffect(() => {
+    if (query) {
+      dispatch({ type: "start", value: { query } });
+      formIds.current.forEach((formId) => {
+        const form = cms.forms.find(formId);
+        if (form) {
+          cms.plugins.remove(form);
+        }
+      });
+    }
+  }, [query, JSON.stringify(variables)]);
   React.useEffect(() => {
     if (state.status === "initialized") {
       cms.api.tina.request(query, { variables }).then((res) => {
@@ -1912,7 +1985,7 @@ const useFormify = ({
         variables
       });
       state.blueprints.map((blueprint) => {
-        const responseAtBlueprint = getIn2(result, getBlueprintAliasPath(blueprint));
+        const responseAtBlueprint = getValueForBlueprint(result, getBlueprintAliasPath(blueprint));
         const location = [];
         const findFormNodes = (res, location2) => {
           if (Array.isArray(res)) {
@@ -1961,6 +2034,9 @@ const useFormify = ({
   React.useEffect(() => {
     if (state.status === "ready") {
       cms.events.subscribe(`forms:reset`, (event) => {
+        if (eventList) {
+          eventList.push(printEvent(event));
+        }
         dispatch({ type: "formOnReset", value: { event } });
       });
       cms.events.subscribe(`forms:fields:onChange`, async (event) => {
@@ -1982,6 +2058,9 @@ const useFormify = ({
                           values
                           _internalSys: sys {
                             path
+                            collection {
+                              name
+                            }
                           }
                         }
                       }
@@ -2012,7 +2091,8 @@ const useFormify = ({
         const form = cms.forms.find(changeSet.formId);
         resolveSubFields({
           formNode: changeSet.formNode,
-          form
+          form,
+          loc: []
         }).then((res) => {
           dispatch({
             type: "setIn",
@@ -2121,22 +2201,15 @@ const useFormify = ({
     const data = {};
     await sequential(form.fields, async (field) => {
       const value = form.values[field.name];
-      const fieldName = field.list ? `${field.name}.[]` : field.name;
       const blueprint = getFormNodeBlueprint(formNode, state);
-      const blueprintName = getBlueprintNamePath(blueprint);
-      const extra = [];
-      if (prefix) {
-        extra.push(prefix);
-      }
-      const matchName = [
-        blueprintName,
-        DATA_NODE_NAME,
-        ...extra,
-        fieldName
-      ].join(".");
+      const { matchName, fieldName } = getMatchName({
+        field,
+        prefix,
+        blueprint
+      });
       const fieldBlueprints = blueprint.fields.filter((fieldBlueprint) => {
         return matchName === getBlueprintNamePath(fieldBlueprint);
-      });
+      }).filter((fbp) => filterFieldBlueprintsByParentTypename(fbp, field.parentTypename));
       switch (field.type) {
         case "object":
           if (field.templates) {
@@ -2150,18 +2223,17 @@ const useFormify = ({
                 if (!Array.isArray(value)) {
                   throw new Error(`Expected value for object list field to be an array`);
                 }
-                const d = [];
-                await sequential(value, async (item, index) => {
+                data[keyName] = await sequential(value, async (item, index) => {
                   const template = field.templates[item._template];
-                  const d2 = await resolveSubFields({
+                  return __spreadProps(__spreadValues({}, await resolveSubFields({
                     formNode,
                     form: { fields: template.fields, values: item },
-                    prefix: [prefix, fieldName].join("."),
+                    prefix: prefix ? [prefix, fieldName].join(".") : fieldName,
                     loc: [...loc, index]
+                  })), {
+                    __typename: field.typeMap[item._template]
                   });
-                  d.push(d2);
                 });
-                data[keyName] = d;
               });
             } else {
               throw new Error("blocks without list true is not yet supported");
@@ -2177,18 +2249,14 @@ const useFormify = ({
                 if (!Array.isArray(value)) {
                   throw new Error(`Expected value for object list field to be an array`);
                 }
-                const d = [];
-                await sequential(value, async (item, index) => {
-                  const d2 = await resolveSubFields({
+                data[keyName] = await sequential(value, async (item, index) => {
+                  return resolveSubFields({
                     formNode,
                     form: { fields: field.fields, values: item },
                     prefix: [prefix, fieldName].join("."),
                     loc: [...loc, index]
                   });
-                  d.push(d2);
-                  return true;
                 });
-                data[keyName] = d;
                 return true;
               });
             } else {
@@ -2198,13 +2266,12 @@ const useFormify = ({
                   data[keyName] = null;
                   return true;
                 }
-                const d = await resolveSubFields({
+                data[keyName] = await resolveSubFields({
                   formNode,
                   form: { fields: field.fields, values: value },
                   prefix: [prefix, fieldName].join("."),
                   loc
                 });
-                data[keyName] = d;
                 return true;
               });
             }
@@ -2225,6 +2292,9 @@ const useFormify = ({
                             values
                             _internalSys: sys {
                               path
+                              collection {
+                                name
+                              }
                             }
                           }
                         }
@@ -2259,12 +2329,13 @@ const useFormify = ({
                       }
                     }
                   `, { variables: { id: value } });
-            const d = await resolveSubFields({
-              formNode: subDocumentFormNode,
-              form: form2,
-              loc: location
+            data[keyName] = __spreadProps(__spreadValues({}, res.node), {
+              data: await resolveSubFields({
+                formNode: subDocumentFormNode,
+                form: form2,
+                loc: location
+              })
             });
-            data[keyName] = __spreadProps(__spreadValues({}, res.node), { data: d });
           });
           break;
         default:
@@ -2332,13 +2403,13 @@ mutation addPendingDocumentMutation(
       return result;
     };
     this.getSchema = async () => {
-      if (!this.schema) {
+      if (!this.gqlSchema) {
         const data = await this.request(getIntrospectionQuery(), {
           variables: {}
         });
-        this.schema = buildClientSchema(data);
+        this.gqlSchema = buildClientSchema(data);
       }
-      return this.schema;
+      return this.gqlSchema;
     };
     this.getOptimizedQuery = async (documentNode) => {
       const data = await this.request(`query GetOptimizedQuery($queryString: String!) {
@@ -2348,6 +2419,13 @@ mutation addPendingDocumentMutation(
       });
       return parse(data.getOptimizedQuery);
     };
+    if (options.schema) {
+      const enrichedSchema = new TinaSchema(__spreadValues({
+        version: { fullVersion: "", major: "", minor: "", patch: "" },
+        meta: { flags: [] }
+      }, addNamespaceToSchema(options.schema, [])));
+      this.schema = enrichedSchema;
+    }
     this.options = options;
     this.setBranch(options.branch);
     this.events.subscribe("branch:change", ({ branchName }) => {
@@ -2557,11 +2635,11 @@ mutation addPendingDocumentMutation(
 const DEFAULT_LOCAL_TINA_GQL_SERVER_URL = "http://localhost:4001/graphql";
 class LocalClient extends Client {
   constructor(props) {
-    const clientProps = {
+    const clientProps = __spreadProps(__spreadValues({}, props), {
       clientId: "",
       branch: "",
       customContentApiUrl: props && props.customContentApiUrl ? props.customContentApiUrl : DEFAULT_LOCAL_TINA_GQL_SERVER_URL
-    };
+    });
     super(clientProps);
   }
   async isAuthorized() {
@@ -3136,11 +3214,13 @@ const TinaCMSProvider2 = (_c) => {
   var _d = _c, {
     query,
     documentCreatorCallback,
-    formifyCallback
+    formifyCallback,
+    schema
   } = _d, props = __objRest(_d, [
     "query",
     "documentCreatorCallback",
-    "formifyCallback"
+    "formifyCallback",
+    "schema"
   ]);
   const validOldSetup = new Boolean(props == null ? void 0 : props.isLocalClient) || new Boolean(props == null ? void 0 : props.clientId) && new Boolean(props == null ? void 0 : props.branch);
   if (!props.apiURL && !validOldSetup) {
@@ -3157,7 +3237,8 @@ const TinaCMSProvider2 = (_c) => {
     tinaioConfig: props.tinaioConfig,
     isLocalClient,
     cmsCallback: props.cmsCallback,
-    mediaStore: props.mediaStore
+    mediaStore: props.mediaStore,
+    schema
   }, /* @__PURE__ */ React.createElement("style", null, styles), /* @__PURE__ */ React.createElement(ErrorBoundary, null, /* @__PURE__ */ React.createElement(DocumentCreator, {
     documentCreatorCallback
   }), /* @__PURE__ */ React.createElement(TinaDataProvider, {
@@ -3885,7 +3966,7 @@ const handleNavigate = (navigate, cms, collection, document) => {
     window.location.href = routeOverride;
     return null;
   } else {
-    navigate(document.sys.filename);
+    navigate(document.sys.breadcrumbs.join("/"));
   }
 };
 const CollectionListPage = () => {
@@ -3918,8 +3999,9 @@ const CollectionListPage = () => {
       }, /* @__PURE__ */ React.createElement("tbody", {
         className: "divide-y divide-gray-150"
       }, documents.map((document) => {
+        const subfolders = document.node.sys.breadcrumbs.slice(0, -1).join("/");
         return /* @__PURE__ */ React.createElement("tr", {
-          key: `document-${document.node.sys.filename}`,
+          key: `document-${document.node.sys.relativePath}`,
           className: ""
         }, /* @__PURE__ */ React.createElement("td", {
           className: "px-6 py-2 whitespace-nowrap"
@@ -3934,7 +4016,9 @@ const CollectionListPage = () => {
           className: "block text-xs text-gray-400 mb-1 uppercase"
         }, "Filename"), /* @__PURE__ */ React.createElement("span", {
           className: "h-5 leading-5 block whitespace-nowrap"
-        }, document.node.sys.filename)))), /* @__PURE__ */ React.createElement("td", {
+        }, subfolders && /* @__PURE__ */ React.createElement("span", {
+          className: "text-xs text-gray-400"
+        }, `${subfolders}/`), /* @__PURE__ */ React.createElement("span", null, document.node.sys.filename))))), /* @__PURE__ */ React.createElement("td", {
           className: "px-6 py-4 whitespace-nowrap"
         }, /* @__PURE__ */ React.createElement("span", {
           className: "block text-xs text-gray-400 mb-1 uppercase"
@@ -4058,6 +4142,22 @@ const RenderForm$1 = ({ cms, collection, template, fields, mutationInfo }) => {
   var _a, _b;
   const navigate = useNavigate();
   const [formIsPristine, setFormIsPristine] = useState(true);
+  const schema = cms.api.tina.schema;
+  let schemaFields = fields;
+  if (schema) {
+    const schemaCollection = schema.getCollection(collection.name);
+    const template2 = schema.getTemplateForData({
+      collection: schemaCollection,
+      data: {}
+    });
+    const formInfo = resolveForm({
+      collection: schemaCollection,
+      basename: schemaCollection.name,
+      schema,
+      template: template2
+    });
+    schemaFields = formInfo.fields;
+  }
   const form = useMemo(() => {
     return new Form({
       id: "create-form",
@@ -4067,7 +4167,7 @@ const RenderForm$1 = ({ cms, collection, template, fields, mutationInfo }) => {
           name: "filename",
           label: "Filename",
           component: "text",
-          description: `A unique filename for the content.  Example: My_Document`,
+          description: /* @__PURE__ */ React.createElement("span", null, "A unique filename for the content.", /* @__PURE__ */ React.createElement("br", null), "Examples: ", /* @__PURE__ */ React.createElement("code", null, "My_Document"), ", ", /* @__PURE__ */ React.createElement("code", null, "My_Document.en"), ",", " ", /* @__PURE__ */ React.createElement("code", null, "sub-folder/My_Document")),
           placeholder: `My_Document`,
           validate: (value, allValues, meta) => {
             if (!value) {
@@ -4076,13 +4176,13 @@ const RenderForm$1 = ({ cms, collection, template, fields, mutationInfo }) => {
               }
               return true;
             }
-            const isValid = /^[_a-zA-Z][.,-,_a-zA-Z0-9]*$/.test(value);
+            const isValid = /^[_a-zA-Z][\.\-_\/a-zA-Z0-9]*$/.test(value);
             if (value && !isValid) {
-              return "Must begin with a-z, A-Z, or _ and contain only a-z, A-Z, 0-9, -, ., or _";
+              return "Must begin with a-z, A-Z, or _ and contain only a-z, A-Z, 0-9, -, _, ., or /.";
             }
           }
         },
-        ...fields
+        ...schemaFields
       ],
       onSubmit: async (values) => {
         try {
@@ -4175,7 +4275,8 @@ const updateDocument = async (cms, relativePath, collection, mutationInfo, value
   }
 };
 const CollectionUpdatePage = () => {
-  const { collectionName, filename } = useParams();
+  const _a = useParams(), { collectionName } = _a, rest = __objRest(_a, ["collectionName"]);
+  const { "*": filename } = rest;
   return /* @__PURE__ */ React.createElement(GetCMS, null, (cms) => /* @__PURE__ */ React.createElement(GetDocumentFields, {
     cms,
     collectionName
@@ -4204,13 +4305,28 @@ const RenderForm = ({
   mutationInfo
 }) => {
   var _a, _b;
-  useNavigate();
   const [formIsPristine, setFormIsPristine] = useState(true);
+  const schema = cms.api.tina.schema;
+  let schemaFields = document.form.fields;
+  if (schema) {
+    const schemaCollection = schema.getCollection(collection.name);
+    const template = schema.getTemplateForData({
+      collection: schemaCollection,
+      data: document.value
+    });
+    const formInfo = resolveForm({
+      collection: schemaCollection,
+      basename: schemaCollection.name,
+      schema,
+      template
+    });
+    schemaFields = formInfo.fields;
+  }
   const form = useMemo(() => {
     return new Form({
       id: "update-form",
       label: "form",
-      fields: document.form.fields,
+      fields: schemaFields,
       initialValues: document.values,
       onSubmit: async (values) => {
         try {
@@ -4294,7 +4410,7 @@ const TinaAdmin = () => {
         path: "collections/:collectionName/:templateName/new",
         element: /* @__PURE__ */ React.createElement(CollectionCreatePage, null)
       }), /* @__PURE__ */ React.createElement(Route, {
-        path: "collections/:collectionName/:filename",
+        path: "collections/:collectionName/*",
         element: /* @__PURE__ */ React.createElement(CollectionUpdatePage, null)
       }), /* @__PURE__ */ React.createElement(Route, {
         path: "collections/:collectionName",