@tinacms/graphql 0.56.0 → 0.57.2

package/dist/index.js

@@ -6395,15 +6395,15 @@ var require_acorn_jsx = __commonJS({
       }
       return acornJsx;
     }
-    function getQualifiedJSXName(object) {
-      if (!object)
-        return object;
-      if (object.type === "JSXIdentifier")
-        return object.name;
-      if (object.type === "JSXNamespacedName")
-        return object.namespace.name + ":" + object.name.name;
-      if (object.type === "JSXMemberExpression")
-        return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property);
+    function getQualifiedJSXName(object2) {
+      if (!object2)
+        return object2;
+      if (object2.type === "JSXIdentifier")
+        return object2.name;
+      if (object2.type === "JSXNamespacedName")
+        return object2.namespace.name + ":" + object2.name.name;
+      if (object2.type === "JSXMemberExpression")
+        return getQualifiedJSXName(object2.object) + "." + getQualifiedJSXName(object2.property);
     }
     module2.exports = function(options) {
       options = options || {};
@@ -6946,8 +6946,8 @@ var require_micromark_extension_mdxjs = __commonJS({
 var require_min_indent = __commonJS({
   "pnp:/home/runner/work/tinacms/tinacms/.yarn/cache/min-indent-npm-1.0.1-77031f50e1-c3aeea46bc.zip/node_modules/min-indent/index.js"(exports, module2) {
     "use strict";
-    module2.exports = (string3) => {
-      const match = string3.match(/^[ \t]*(?=\S)/gm);
+    module2.exports = (string4) => {
+      const match = string4.match(/^[ \t]*(?=\S)/gm);
       if (!match) {
         return 0;
       }
@@ -6961,13 +6961,13 @@ var require_strip_indent = __commonJS({
   "pnp:/home/runner/work/tinacms/tinacms/.yarn/cache/strip-indent-npm-3.0.0-519e75a28d-4a7860e943.zip/node_modules/strip-indent/index.js"(exports, module2) {
     "use strict";
     var minIndent = require_min_indent();
-    module2.exports = (string3) => {
-      const indent2 = minIndent(string3);
+    module2.exports = (string4) => {
+      const indent2 = minIndent(string4);
       if (indent2 === 0) {
-        return string3;
+        return string4;
       }
       const regex = new RegExp(`^[ \\t]{${indent2}}`, "gm");
-      return string3.replace(regex, "");
+      return string4.replace(regex, "");
     };
   }
 });
@@ -10101,7 +10101,7 @@ var require_repeat_string = __commonJS({
   "pnp:/home/runner/work/tinacms/tinacms/.yarn/cache/repeat-string-npm-1.6.1-bc8e388655-99c431ba7b.zip/node_modules/repeat-string/index.js"(exports, module2) {
     "use strict";
     var res = "";
-    var cache3;
+    var cache;
     module2.exports = repeat;
     function repeat(str, num) {
       if (typeof str !== "string") {
@@ -10112,8 +10112,8 @@ var require_repeat_string = __commonJS({
       if (num === 2)
         return str + str;
       var max = str.length * num;
-      if (cache3 !== str || typeof cache3 === "undefined") {
-        cache3 = str;
+      if (cache !== str || typeof cache === "undefined") {
+        cache = str;
         res = "";
       } else if (res.length >= max) {
         return res.substr(0, max);
@@ -10386,36 +10386,22 @@ var require_remark_mdx = __commonJS({
 __export(exports, {
   GithubBridge: () => GithubBridge,
   buildSchema: () => buildSchema,
-  clearCache: () => clearCache,
   createBranch: () => createBranch,
   createDatabase: () => createDatabase,
   githubRoute: () => githubRoute,
   gql: () => gql,
   indexDB: () => indexDB,
   listBranches: () => listBranches,
-  lruClearCache: () => clearCache,
-  resolve: () => resolve,
-  s3Cache: () => s3Cache,
-  s3ClearCache: () => clearCache2,
-  simpleCache: () => simpleCache2
+  resolve: () => resolve
 });
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/database/github.ts
 var import_lodash = __toModule(require("lodash"));
 var import_path = __toModule(require("path"));
 var import_rest = __toModule(require("@octokit/rest"));
-var import_lru_cache = __toModule(require("lru-cache"));
 var import_graphql = __toModule(require("graphql"));
 var GithubBridge = class {
-  constructor({
-    rootPath,
-    accessToken,
-    owner,
-    repo,
-    ref,
-    cache: cache3
-  }) {
-    this.cache = cache3 || simpleCache;
+  constructor({ rootPath, accessToken, owner, repo, ref }) {
     this.rootPath = rootPath;
     this.repoConfig = {
       owner,
@@ -10426,12 +10412,9 @@ var GithubBridge = class {
       auth: accessToken
     });
   }
-  generateKey(key2) {
-    return `${this.repoConfig.owner}/${this.repoConfig.repo}/${this.repoConfig.ref}/${key2}`;
-  }
   async readDir(filepath) {
     const fullPath = import_path.default.join(this.rootPath, filepath);
-    return import_lodash.default.flatten((await this.cache.get(this.generateKey(fullPath), async () => this.appOctoKit.repos.getContent(__spreadProps(__spreadValues({}, this.repoConfig), {
+    const repos = await this.appOctoKit.repos.getContent(__spreadProps(__spreadValues({}, this.repoConfig), {
       path: fullPath
     })).then(async (response) => {
       if (Array.isArray(response.data)) {
@@ -10443,14 +10426,15 @@ var GithubBridge = class {
                 return import_path.default.join(d.path, nestedItem);
               });
             } else {
-              throw new Error("meh");
+              throw new Error(`Expected items to be an array of strings for readDir at ${d.path}`);
             }
           }
           return d.path;
         }));
       }
       throw new Error(`Expected to return an array from Github directory ${import_path.default}`);
-    }))).toString().split(","));
+    });
+    return import_lodash.default.flatten(repos);
   }
   async glob(pattern) {
     const results = await this.readDir(pattern);
@@ -10458,17 +10442,15 @@ var GithubBridge = class {
   }
   async get(filepath) {
     const realpath = import_path.default.join(this.rootPath, filepath);
-    return this.cache.get(this.generateKey(realpath), async () => {
-      return this.appOctoKit.repos.getContent(__spreadProps(__spreadValues({}, this.repoConfig), {
-        path: realpath
-      })).then((response) => {
-        return Buffer.from(response.data.content, "base64").toString();
-      }).catch((e) => {
-        if (e.status === 401) {
-          throw new import_graphql.GraphQLError(`Unauthorized request to Github Repository: '${this.repoConfig.owner}/${this.repoConfig.repo}', please ensure your access token is valid.`, null, null, null, null, e, { status: e.status });
-        }
-        throw new import_graphql.GraphQLError(`Unable to find record '${filepath}' in Github Repository: '${this.repoConfig.owner}/${this.repoConfig.repo}', Ref: '${this.repoConfig.ref}'`, null, null, null, null, e, { status: e.status });
-      });
+    return this.appOctoKit.repos.getContent(__spreadProps(__spreadValues({}, this.repoConfig), {
+      path: realpath
+    })).then((response) => {
+      return Buffer.from(response.data.content, "base64").toString();
+    }).catch((e) => {
+      if (e.status === 401) {
+        throw new import_graphql.GraphQLError(`Unauthorized request to Github Repository: '${this.repoConfig.owner}/${this.repoConfig.repo}', please ensure your access token is valid.`, null, null, null, null, e, { status: e.status });
+      }
+      throw new import_graphql.GraphQLError(`Unable to find record '${filepath}' in Github Repository: '${this.repoConfig.owner}/${this.repoConfig.repo}', Ref: '${this.repoConfig.ref}'`, null, null, null, null, e, { status: e.status });
     });
   }
   async put(filepath, data) {
@@ -10491,36 +10473,87 @@ var GithubBridge = class {
     }));
   }
 };
-var cache = new import_lru_cache.default({
-  max: 1e3,
-  length: function(v) {
-    return v.length;
-  }
-});
-var simpleCache = {
-  get: async (keyName, setter) => {
-    const value = cache.get(keyName);
-    if (value) {
-      console.log("getting from cache", keyName);
-      return value;
-    } else {
-      const valueToCache = await setter();
-      const isSet = cache.set(keyName, valueToCache);
-      console.log("item not in cache, setting", keyName, isSet);
-      return valueToCache;
-    }
-  }
-};
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/index.ts
-var import_fs_extra2 = __toModule(require("fs-extra"));
-var import_path6 = __toModule(require("path"));
+var import_fs_extra3 = __toModule(require("fs-extra"));
+var import_path7 = __toModule(require("path"));
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/build.ts
 var import_lodash4 = __toModule(require("lodash"));
+var import_fs_extra = __toModule(require("fs-extra"));
+var import_path2 = __toModule(require("path"));
+var import_graphql3 = __toModule(require("graphql"));
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/ast-builder/index.ts
 var import_lodash2 = __toModule(require("lodash"));
+var SysFieldDefinition = {
+  kind: "Field",
+  name: {
+    kind: "Name",
+    value: "sys"
+  },
+  arguments: [],
+  directives: [],
+  selectionSet: {
+    kind: "SelectionSet",
+    selections: [
+      {
+        kind: "Field",
+        name: {
+          kind: "Name",
+          value: "filename"
+        },
+        arguments: [],
+        directives: []
+      },
+      {
+        kind: "Field",
+        name: {
+          kind: "Name",
+          value: "basename"
+        },
+        arguments: [],
+        directives: []
+      },
+      {
+        kind: "Field",
+        name: {
+          kind: "Name",
+          value: "breadcrumbs"
+        },
+        arguments: [],
+        directives: []
+      },
+      {
+        kind: "Field",
+        name: {
+          kind: "Name",
+          value: "path"
+        },
+        arguments: [],
+        directives: []
+      },
+      {
+        kind: "Field",
+        name: {
+          kind: "Name",
+          value: "relativePath"
+        },
+        arguments: [],
+        directives: []
+      },
+      {
+        kind: "Field",
+        name: {
+          kind: "Name",
+          value: "extension"
+        },
+        arguments: [],
+        directives: []
+      }
+    ]
+  }
+};
 var astBuilder = {
   FormFieldBuilder: ({
     name,
@@ -10640,6 +10673,16 @@ var astBuilder = {
       })
     };
   },
+  FieldNodeDefinition: ({
+    name,
+    type,
+    args = [],
+    list: list3,
+    required
+  }) => ({
+    name: { kind: "Name", value: name },
+    kind: "Field"
+  }),
   FieldDefinition: ({
     name,
     type,
@@ -10772,6 +10815,63 @@ var astBuilder = {
     },
     fields
   }),
+  FieldWithSelectionSetDefinition: ({
+    name,
+    selections
+  }) => {
+    return {
+      name: { kind: "Name", value: name },
+      kind: "Field",
+      selectionSet: {
+        kind: "SelectionSet",
+        selections
+      }
+    };
+  },
+  InlineFragmentDefinition: ({
+    name,
+    selections
+  }) => {
+    return {
+      kind: "InlineFragment",
+      selectionSet: {
+        kind: "SelectionSet",
+        selections
+      },
+      typeCondition: {
+        kind: "NamedType",
+        name: {
+          kind: "Name",
+          value: name
+        }
+      }
+    };
+  },
+  FragmentDefinition: ({
+    name,
+    fragmentName,
+    selections
+  }) => {
+    return {
+      kind: "FragmentDefinition",
+      name: {
+        kind: "Name",
+        value: fragmentName
+      },
+      typeCondition: {
+        kind: "NamedType",
+        name: {
+          kind: "Name",
+          value: name
+        }
+      },
+      directives: [],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections
+      }
+    };
+  },
   TYPES: {
     Scalar: (type) => {
       const scalars = {
@@ -10799,6 +10899,204 @@ var astBuilder = {
     Number: "Int",
     Document: "Document"
   },
+  QueryOperationDefinition: ({
+    queryName,
+    fragName
+  }) => {
+    return {
+      kind: "OperationDefinition",
+      operation: "query",
+      name: {
+        kind: "Name",
+        value: queryName
+      },
+      variableDefinitions: [
+        {
+          kind: "VariableDefinition",
+          type: {
+            kind: "NonNullType",
+            type: {
+              kind: "NamedType",
+              name: { kind: "Name", value: "String" }
+            }
+          },
+          variable: {
+            kind: "Variable",
+            name: { kind: "Name", value: "relativePath" }
+          }
+        }
+      ],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: {
+              kind: "Name",
+              value: queryName
+            },
+            arguments: [
+              {
+                kind: "Argument",
+                name: {
+                  kind: "Name",
+                  value: "relativePath"
+                },
+                value: {
+                  kind: "Variable",
+                  name: {
+                    kind: "Name",
+                    value: "relativePath"
+                  }
+                }
+              }
+            ],
+            directives: [],
+            selectionSet: {
+              kind: "SelectionSet",
+              selections: [
+                SysFieldDefinition,
+                {
+                  kind: "Field",
+                  name: {
+                    kind: "Name",
+                    value: "id"
+                  },
+                  arguments: [],
+                  directives: []
+                },
+                {
+                  kind: "Field",
+                  name: {
+                    kind: "Name",
+                    value: "data"
+                  },
+                  arguments: [],
+                  directives: [],
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      {
+                        kind: "FragmentSpread",
+                        name: {
+                          kind: "Name",
+                          value: fragName
+                        },
+                        directives: []
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    };
+  },
+  ListQueryOperationDefinition: ({
+    queryName,
+    fragName
+  }) => {
+    return {
+      kind: "OperationDefinition",
+      operation: "query",
+      name: {
+        kind: "Name",
+        value: queryName
+      },
+      variableDefinitions: [],
+      directives: [],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: {
+              kind: "Name",
+              value: queryName
+            },
+            arguments: [],
+            directives: [],
+            selectionSet: {
+              kind: "SelectionSet",
+              selections: [
+                {
+                  kind: "Field",
+                  name: {
+                    kind: "Name",
+                    value: "totalCount"
+                  },
+                  arguments: [],
+                  directives: []
+                },
+                {
+                  kind: "Field",
+                  name: {
+                    kind: "Name",
+                    value: "edges"
+                  },
+                  arguments: [],
+                  directives: [],
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      {
+                        kind: "Field",
+                        name: {
+                          kind: "Name",
+                          value: "node"
+                        },
+                        arguments: [],
+                        directives: [],
+                        selectionSet: {
+                          kind: "SelectionSet",
+                          selections: [
+                            {
+                              kind: "Field",
+                              name: {
+                                kind: "Name",
+                                value: "id"
+                              },
+                              arguments: [],
+                              directives: []
+                            },
+                            SysFieldDefinition,
+                            {
+                              kind: "Field",
+                              name: {
+                                kind: "Name",
+                                value: "data"
+                              },
+                              arguments: [],
+                              directives: [],
+                              selectionSet: {
+                                kind: "SelectionSet",
+                                selections: [
+                                  {
+                                    kind: "FragmentSpread",
+                                    name: {
+                                      kind: "Name",
+                                      value: fragName
+                                    },
+                                    directives: []
+                                  }
+                                ]
+                              }
+                            }
+                          ]
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    };
+  },
   toGraphQLAst: (ast) => {
     const definitions = import_lodash2.default.uniqBy([
       ...extractInlineTypes(ast.query),
@@ -10870,6 +11168,9 @@ function addNamespaceToSchema(maybeNode, namespace = []) {
     const key2 = keys2[index2];
     if (Array.isArray(m)) {
       newNode[key2] = m.map((element) => {
+        if (!element) {
+          return;
+        }
         if (!element.hasOwnProperty("name")) {
           return element;
         }
@@ -10877,6 +11178,9 @@ function addNamespaceToSchema(maybeNode, namespace = []) {
         return addNamespaceToSchema(element, [...namespace, value]);
       });
     } else {
+      if (!m) {
+        return;
+      }
       if (!m.hasOwnProperty("name")) {
         newNode[key2] = m;
       } else {
@@ -10914,6 +11218,9 @@ var NAMER = {
   generateQueryListName: (namespace) => {
     return "get" + generateNamespacedFieldName(namespace, "List");
   },
+  fragmentName: (namespace) => {
+    return generateNamespacedFieldName(namespace, "") + "Parts";
+  },
   collectionTypeName: (namespace) => {
     return generateNamespacedFieldName(namespace, "Collection");
   },
@@ -11266,7 +11573,7 @@ var Builder = class {
         args: [
           astBuilder.InputValueDefinition({
             name: "collection",
-            required: true,
+            required: false,
             type: astBuilder.TYPES.String
           }),
           astBuilder.InputValueDefinition({
@@ -11293,7 +11600,7 @@ var Builder = class {
         args: [
           astBuilder.InputValueDefinition({
             name: "collection",
-            required: true,
+            required: false,
             type: astBuilder.TYPES.String
           }),
           astBuilder.InputValueDefinition({
@@ -11341,6 +11648,104 @@ var Builder = class {
       });
       return astBuilder.FieldDefinition({ type, name, args, required: true });
     };
+    this.collectionFragment = async (collection) => {
+      const name = NAMER.dataTypeName(collection.namespace);
+      const fragmentName = NAMER.fragmentName(collection.namespace);
+      if (typeof collection.fields === "object") {
+        const selections = [];
+        await sequential(collection.fields, async (x) => {
+          const field = await this._buildFieldNodeForFragments(x);
+          selections.push(field);
+        });
+        return astBuilder.FragmentDefinition({
+          name,
+          fragmentName,
+          selections: filterSelections(selections)
+        });
+      } else {
+        const selections = [];
+        await sequential(collection.templates, async (tem) => {
+          if (typeof tem === "object") {
+            selections.push(await this.buildTemplateFragments(tem));
+          }
+        });
+        return astBuilder.FieldWithSelectionSetDefinition({
+          name,
+          selections: filterSelections(selections)
+        });
+      }
+    };
+    this._buildFieldNodeForFragments = async (field) => {
+      switch (field.type) {
+        case "string":
+        case "image":
+        case "datetime":
+        case "number":
+        case "boolean":
+        case "rich-text":
+          return astBuilder.FieldNodeDefinition(field);
+        case "object":
+          if (typeof field.fields === "object") {
+            const selections = [];
+            await sequential(field.fields, async (item) => {
+              const field2 = await this._buildFieldNodeForFragments(item);
+              selections.push(field2);
+            });
+            return astBuilder.FieldWithSelectionSetDefinition({
+              name: field.name,
+              selections: [
+                { kind: "Field", name: { kind: "Name", value: "__typename" } },
+                ...filterSelections(selections)
+              ]
+            });
+          } else if (typeof field.templates === "object") {
+            const selections = [];
+            await sequential(field.templates, async (tem) => {
+              if (typeof tem === "object") {
+                selections.push(await this.buildTemplateFragments(tem));
+              }
+            });
+            return astBuilder.FieldWithSelectionSetDefinition({
+              name: field.name,
+              selections: [
+                { kind: "Field", name: { kind: "Name", value: "__typename" } },
+                ...filterSelections(selections)
+              ]
+            });
+          }
+        case "reference":
+          return astBuilder.FieldWithSelectionSetDefinition({
+            name: field.name,
+            selections: [
+              {
+                kind: "InlineFragment",
+                typeCondition: {
+                  kind: "NamedType",
+                  name: {
+                    kind: "Name",
+                    value: "Document"
+                  }
+                },
+                directives: [],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    {
+                      kind: "Field",
+                      name: {
+                        kind: "Name",
+                        value: "id"
+                      },
+                      arguments: [],
+                      directives: []
+                    }
+                  ]
+                }
+              }
+            ]
+          });
+      }
+    };
     this.updateCollectionDocumentMutation = async (collection) => {
       return astBuilder.FieldDefinition({
         type: await this._buildCollectionDocumentType(collection),
@@ -11687,6 +12092,17 @@ Visit https://tina.io/docs/errors/ui-not-supported/ for more information
     this.tinaSchema = config.tinaSchema;
     this.database = config.database;
   }
+  async buildTemplateFragments(template) {
+    const selections = [];
+    await sequential(template.fields || [], async (item) => {
+      const field = await this._buildFieldNodeForFragments(item);
+      selections.push(field);
+    });
+    return astBuilder.InlineFragmentDefinition({
+      selections: filterSelections(selections),
+      name: NAMER.dataTypeName(template.namespace)
+    });
+  }
 };
 var listArgs = [
   astBuilder.InputValueDefinition({
@@ -11706,9 +12122,81 @@ var listArgs = [
     type: astBuilder.TYPES.Number
   })
 ];
+var filterSelections = (arr) => {
+  return arr.filter(Boolean);
+};
 
-// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/schema/index.ts
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/schema/validate.ts
 var import_lodash3 = __toModule(require("lodash"));
+var yup2 = __toModule(require("yup"));
+var FIELD_TYPES = [
+  "string",
+  "number",
+  "boolean",
+  "datetime",
+  "image",
+  "reference",
+  "object",
+  "rich-text"
+];
+var validateSchema = async (schema) => {
+  const schema2 = addNamespaceToSchema(import_lodash3.default.cloneDeep(schema));
+  const collections = await sequential(schema2.collections, async (collection) => validateCollection(collection));
+  return {
+    collections
+  };
+};
+var validateCollection = async (collection) => {
+  let templates = [];
+  let fields = [];
+  const messageName = collection.namespace.join(".");
+  const collectionSchema = yup2.object({
+    name: yup2.string().matches(/^[a-zA-Z0-9_]*$/, {
+      message: (obj) => `Collection's "name" must match ${obj.regex} at ${messageName}`
+    }).required(),
+    label: yup2.string().required(),
+    path: yup2.string().required().transform((value) => {
+      return value.replace(/^\/|\/$/g, "");
+    })
+  });
+  await collectionSchema.validate(collection);
+  const validCollection = await collectionSchema.cast(collection);
+  if (validCollection.templates) {
+    templates = await sequential(validCollection.templates, async (template) => {
+      if (typeof template === "string") {
+        throw new Error(`Global templates are not yet supported`);
+      }
+      const fields2 = await sequential(template.fields, async (field) => {
+        return validateField(field);
+      });
+      return __spreadValues(__spreadValues({}, validCollection), fields2);
+    });
+  }
+  if (validCollection.fields) {
+    if (typeof validCollection.fields === "string") {
+      throw new Error(`Global templates are not yet supported`);
+    }
+    fields = await sequential(validCollection.fields, async (field) => {
+      return validateField(field);
+    });
+    return __spreadProps(__spreadValues({}, validCollection), {
+      fields
+    });
+  }
+  return collection;
+};
+var validateField = async (field) => {
+  const messageName = field.namespace.join(".");
+  const schema = yup2.object({
+    name: yup2.string().matches(/^[a-zA-Z0-9_]*$/, {
+      message: (obj) => `Field's 'name' must match ${obj.regex} at ${messageName}`
+    }).required(),
+    label: yup2.string().required(),
+    type: yup2.string().oneOf(FIELD_TYPES, (obj) => `'type' must be one of: ${obj.values}, but got '${obj.value}' at ${messageName}`)
+  });
+  await schema.validate(field);
+  return field;
+};
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/resolver/error.ts
 var TinaError = class extends Error {
@@ -11725,7 +12213,8 @@ var TinaError = class extends Error {
 var createSchema = async ({
   schema
 }) => {
-  return new TinaSchema(schema);
+  const validSchema = await validateSchema(schema);
+  return new TinaSchema(validSchema);
 };
 var TinaSchema = class {
   constructor(config) {
@@ -11810,7 +12299,7 @@ var TinaSchema = class {
         case "object":
           return templateInfo.template;
         case "union":
-          assertShape(data, (yup2) => yup2.object({ _template: yup2.string().required() }));
+          assertShape(data, (yup3) => yup3.object({ _template: yup3.string().required() }));
           const template = templateInfo.templates.find((template2) => template2.namespace[template2.namespace.length - 1] === data._template);
           if (!template) {
             throw new TinaError(`Expected to find template named '${data._template}' for collection '${lastItem(collection.namespace)}'`, {
@@ -11867,7 +12356,7 @@ var TinaSchema = class {
         }
       }
     };
-    this.schema = addNamespaceToSchema(import_lodash3.default.cloneDeep(config));
+    this.schema = config;
   }
 };
 
@@ -11878,6 +12367,42 @@ var indexDB = async ({ database, config }) => {
   const graphQLSchema = await _buildSchema(builder, tinaSchema);
   await database.put("_graphql", graphQLSchema);
   await database.put("_schema", tinaSchema.schema);
+  await _buildFragments(builder, tinaSchema);
+  await _buildQueries(builder, tinaSchema);
+};
+var _buildFragments = async (builder, tinaSchema) => {
+  const fragmentDefinitionsFields = [];
+  const collections = tinaSchema.getCollections();
+  await sequential(collections, async (collection) => {
+    const frag = await builder.collectionFragment(collection);
+    fragmentDefinitionsFields.push(frag);
+  });
+  const fragDoc = {
+    kind: "Document",
+    definitions: import_lodash4.default.uniqBy(extractInlineTypes(fragmentDefinitionsFields), (node) => node.name.value)
+  };
+  const fragPath = import_path2.default.join(process.cwd(), ".tina", "__generated__");
+  await import_fs_extra.default.outputFileSync(import_path2.default.join(fragPath, "frags.gql"), (0, import_graphql3.print)(fragDoc));
+};
+var _buildQueries = async (builder, tinaSchema) => {
+  const operationsDefinitions = [];
+  const collections = tinaSchema.getCollections();
+  await sequential(collections, async (collection) => {
+    const queryName = NAMER.queryName(collection.namespace);
+    const queryListName = NAMER.generateQueryListName(collection.namespace);
+    const fragName = NAMER.fragmentName(collection.namespace);
+    operationsDefinitions.push(astBuilder.QueryOperationDefinition({ fragName, queryName }));
+    operationsDefinitions.push(astBuilder.ListQueryOperationDefinition({
+      fragName,
+      queryName: queryListName
+    }));
+  });
+  const queryDoc = {
+    kind: "Document",
+    definitions: import_lodash4.default.uniqBy(extractInlineTypes(operationsDefinitions), (node) => node.name.value)
+  };
+  const fragPath = import_path2.default.join(process.cwd(), ".tina", "__generated__");
+  await import_fs_extra.default.outputFileSync(import_path2.default.join(fragPath, "queries.gql"), (0, import_graphql3.print)(queryDoc));
 };
 var _buildSchema = async (builder, tinaSchema) => {
   const definitions = [];
@@ -11908,19 +12433,20 @@ var _buildSchema = async (builder, tinaSchema) => {
     name: "Mutation",
     fields: mutationTypeDefinitionFields
   }));
-  return {
+  const doc = {
     kind: "Document",
     definitions: import_lodash4.default.uniqBy(extractInlineTypes(definitions), (node) => node.name.value)
   };
+  return doc;
 };
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/resolve.ts
 var import_lodash7 = __toModule(require("lodash"));
-var import_graphql3 = __toModule(require("graphql"));
+var import_graphql4 = __toModule(require("graphql"));
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/resolver/index.ts
 var import_lodash6 = __toModule(require("lodash"));
-var import_path3 = __toModule(require("path"));
+var import_path4 = __toModule(require("path"));
 var import_isValid = __toModule(require_isValid());
 
 // pnp:/home/runner/work/tinacms/tinacms/.yarn/cache/bail-npm-2.0.1-faf99b7186-eab36a71a1.zip/node_modules/bail/index.js
@@ -12114,7 +12640,7 @@ VFileMessage.prototype.ruleId = null;
 VFileMessage.prototype.position = null;
 
 // pnp:/home/runner/work/tinacms/tinacms/.yarn/cache/vfile-npm-5.1.0-4fbf325323-b36786f162.zip/node_modules/vfile/lib/minpath.js
-var import_path2 = __toModule(require("path"));
+var import_path3 = __toModule(require("path"));
 
 // pnp:/home/runner/work/tinacms/tinacms/.yarn/cache/vfile-npm-5.1.0-4fbf325323-b36786f162.zip/node_modules/vfile/lib/minproc.js
 var import_process = __toModule(require("process"));
@@ -12166,32 +12692,32 @@ var VFile = class {
   get path() {
     return this.history[this.history.length - 1];
   }
-  set path(path7) {
-    if (isUrl(path7)) {
-      path7 = (0, import_url.fileURLToPath)(path7);
+  set path(path8) {
+    if (isUrl(path8)) {
+      path8 = (0, import_url.fileURLToPath)(path8);
     }
-    assertNonEmpty(path7, "path");
-    if (this.path !== path7) {
-      this.history.push(path7);
+    assertNonEmpty(path8, "path");
+    if (this.path !== path8) {
+      this.history.push(path8);
     }
   }
   get dirname() {
-    return typeof this.path === "string" ? import_path2.default.dirname(this.path) : void 0;
+    return typeof this.path === "string" ? import_path3.default.dirname(this.path) : void 0;
   }
   set dirname(dirname) {
     assertPath(this.basename, "dirname");
-    this.path = import_path2.default.join(dirname || "", this.basename);
+    this.path = import_path3.default.join(dirname || "", this.basename);
   }
   get basename() {
-    return typeof this.path === "string" ? import_path2.default.basename(this.path) : void 0;
+    return typeof this.path === "string" ? import_path3.default.basename(this.path) : void 0;
   }
   set basename(basename) {
     assertNonEmpty(basename, "basename");
     assertPart(basename, "basename");
-    this.path = import_path2.default.join(this.dirname || "", basename);
+    this.path = import_path3.default.join(this.dirname || "", basename);
   }
   get extname() {
-    return typeof this.path === "string" ? import_path2.default.extname(this.path) : void 0;
+    return typeof this.path === "string" ? import_path3.default.extname(this.path) : void 0;
   }
   set extname(extname) {
     assertPart(extname, "extname");
@@ -12204,15 +12730,15 @@ var VFile = class {
         throw new Error("`extname` cannot contain multiple dots");
       }
     }
-    this.path = import_path2.default.join(this.dirname, this.stem + (extname || ""));
+    this.path = import_path3.default.join(this.dirname, this.stem + (extname || ""));
   }
   get stem() {
-    return typeof this.path === "string" ? import_path2.default.basename(this.path, this.extname) : void 0;
+    return typeof this.path === "string" ? import_path3.default.basename(this.path, this.extname) : void 0;
   }
   set stem(stem) {
     assertNonEmpty(stem, "stem");
     assertPart(stem, "stem");
-    this.path = import_path2.default.join(this.dirname || "", stem + (this.extname || ""));
+    this.path = import_path3.default.join(this.dirname || "", stem + (this.extname || ""));
   }
   toString(encoding) {
     return (this.value || "").toString(encoding);
@@ -12239,8 +12765,8 @@ var VFile = class {
   }
 };
 function assertPart(part, name) {
-  if (part && part.includes(import_path2.default.sep)) {
-    throw new Error("`" + name + "` cannot be a path: did not expect `" + import_path2.default.sep + "`");
+  if (part && part.includes(import_path3.default.sep)) {
+    throw new Error("`" + name + "` cannot be a path: did not expect `" + import_path3.default.sep + "`");
   }
 }
 function assertNonEmpty(part, name) {
@@ -12248,8 +12774,8 @@ function assertNonEmpty(part, name) {
     throw new Error("`" + name + "` cannot be empty");
   }
 }
-function assertPath(path7, name) {
-  if (!path7) {
+function assertPath(path8, name) {
+  if (!path8) {
     throw new Error("Setting `" + name + "` requires `path` to be set too");
   }
 }
@@ -17770,7 +18296,7 @@ function initializeFlow(effects) {
 var resolver = {
   resolveAll: createResolver()
 };
-var string = initializeFactory("string");
+var string2 = initializeFactory("string");
 var text = initializeFactory("text");
 function initializeFactory(field) {
   return {
@@ -18195,7 +18721,7 @@ __export(constructs_exports, {
   flow: () => flow2,
   flowInitial: () => flowInitial,
   insideSpan: () => insideSpan,
-  string: () => string2,
+  string: () => string3,
   text: () => text2
 });
 var document2 = {
@@ -18232,7 +18758,7 @@ var flow2 = {
   [96]: codeFenced,
   [126]: codeFenced
 };
-var string2 = {
+var string3 = {
   [38]: characterReference,
   [92]: characterEscape
 };
@@ -18270,7 +18796,7 @@ function parse(options = {}) {
     content: create(content),
     document: create(document),
     flow: create(flow),
-    string: create(string),
+    string: create(string2),
     text: create(text)
   };
   return parser;
@@ -18863,9 +19389,9 @@ function compiler(options = {}) {
   }
   function onexitlabeltext(token) {
     const ancestor = this.stack[this.stack.length - 2];
-    const string3 = this.sliceSerialize(token);
-    ancestor.label = decodeString(string3);
-    ancestor.identifier = normalizeIdentifier(string3).toLowerCase();
+    const string4 = this.sliceSerialize(token);
+    ancestor.label = decodeString(string4);
+    ancestor.identifier = normalizeIdentifier(string4).toLowerCase();
   }
   function onexitlabel() {
     const fragment = this.stack[this.stack.length - 1];
@@ -21379,8 +21905,8 @@ var Resolver = class {
           data: rawData,
           collection
         });
-        const basename = import_path3.default.basename(fullPath);
-        const extension2 = import_path3.default.extname(fullPath);
+        const basename = import_path4.default.basename(fullPath);
+        const extension2 = import_path4.default.extname(fullPath);
         const filename = basename.replace(extension2, "");
         const relativePath = fullPath.replace("\\", "/").replace(collection.path, "").replace(/^\/|\/$/g, "");
         const breadcrumbs = filename.split("/");
@@ -21446,6 +21972,7 @@ var Resolver = class {
               const templates = {};
               await sequential(collectable.templates, async (template) => {
                 templates[lastItem(template.namespace)] = {
+                  template,
                   fields: await sequential(template.fields, async (field) => {
                     return this.resolveField(field);
                   })
@@ -21464,64 +21991,111 @@ var Resolver = class {
         throw e;
       }
     };
-    this.resolveDocument = async ({
-      value,
-      args,
-      collection: collectionName,
-      isMutation,
-      isCreation
-    }) => {
-      const collectionNames = this.tinaSchema.getCollections().map((item) => item.name);
-      assertShape(collectionName, (yup2) => {
-        return yup2.mixed().oneOf(collectionNames);
-      }, `"collection" must be one of: [${collectionNames.join(", ")}] but got ${collectionName}`);
-      assertShape(args, (yup2) => yup2.object({ relativePath: yup2.string().required() }));
-      const collection = await this.tinaSchema.getCollection(collectionName);
-      const realPath = import_path3.default.join(collection == null ? void 0 : collection.path, args.relativePath);
-      if (isMutation) {
-        if (isCreation) {
-          if (await this.database.documentExists(realPath)) {
-            throw new Error(`Unable to add document, ${realPath} already exists`);
-          }
-          const templateInfo2 = this.tinaSchema.getTemplatesForCollectable(collection);
-          switch (templateInfo2.type) {
-            case "object":
-              await this.database.put(realPath, {});
-              break;
-            case "union":
-              const templateString = args.template;
-              const template = templateInfo2.templates.find((template2) => lastItem(template2.namespace) === templateString);
-              if (!args.template) {
-                throw new Error(`Must specify a template when creating content for a collection with multiple templates. Possible templates are: ${templateInfo2.templates.map((t) => lastItem(t.namespace)).join(" ")}`);
-              }
-              if (!template) {
-                throw new Error(`Expected to find template named ${templateString} in collection "${collectionName}" but none was found. Possible templates are: ${templateInfo2.templates.map((t) => lastItem(t.namespace)).join(" ")}`);
+    this.buildObjectMutations = (fieldValue, field) => {
+      if (field.fields) {
+        const objectTemplate = typeof field.fields === "string" ? this.tinaSchema.getGlobalTemplate(field.fields) : field;
+        if (Array.isArray(fieldValue)) {
+          return fieldValue.map((item) => this.buildFieldMutations(item, objectTemplate));
+        } else {
+          return this.buildFieldMutations(fieldValue, objectTemplate);
+        }
+      }
+      if (field.templates) {
+        if (Array.isArray(fieldValue)) {
+          return fieldValue.map((item) => {
+            if (typeof item === "string") {
+              throw new Error(`Expected object for template value for field ${field.name}`);
+            }
+            const templates = field.templates.map((templateOrTemplateName) => {
+              if (typeof templateOrTemplateName === "string") {
+                return this.tinaSchema.getGlobalTemplate(templateOrTemplateName);
               }
-              await this.database.put(realPath, {
-                _template: lastItem(template.namespace)
-              });
-              return this.getDocument(realPath);
-          }
+              return templateOrTemplateName;
+            });
+            const [templateName] = Object.entries(item)[0];
+            const template = templates.find((template2) => template2.name === templateName);
+            if (!template) {
+              throw new Error(`Expected to find template ${templateName}`);
+            }
+            return __spreadProps(__spreadValues({}, this.buildFieldMutations(item[template.name], template)), {
+              _template: template.name
+            });
+          });
         } else {
-          if (!await this.database.documentExists(realPath)) {
-            throw new Error(`Unable to update document, ${realPath} does not exist`);
+          if (typeof fieldValue === "string") {
+            throw new Error(`Expected object for template value for field ${field.name}`);
           }
+          const templates = field.templates.map((templateOrTemplateName) => {
+            if (typeof templateOrTemplateName === "string") {
+              return this.tinaSchema.getGlobalTemplate(templateOrTemplateName);
+            }
+            return templateOrTemplateName;
+          });
+          const [templateName] = Object.entries(fieldValue)[0];
+          const template = templates.find((template2) => template2.name === templateName);
+          if (!template) {
+            throw new Error(`Expected to find template ${templateName}`);
+          }
+          return __spreadProps(__spreadValues({}, this.buildFieldMutations(fieldValue[template.name], template)), {
+            _template: template.name
+          });
         }
+      }
+    };
+    this.createResolveDocument = async ({
+      collection,
+      realPath,
+      args,
+      isAddPendingDocument
+    }) => {
+      if (isAddPendingDocument === true) {
+        const templateInfo = this.tinaSchema.getTemplatesForCollectable(collection);
+        switch (templateInfo.type) {
+          case "object":
+            await this.database.put(realPath, {});
+            break;
+          case "union":
+            const templateString = args.template;
+            const template = templateInfo.templates.find((template2) => lastItem(template2.namespace) === templateString);
+            if (!args.template) {
+              throw new Error(`Must specify a template when creating content for a collection with multiple templates. Possible templates are: ${templateInfo.templates.map((t) => lastItem(t.namespace)).join(" ")}`);
+            }
+            if (!template) {
+              throw new Error(`Expected to find template named ${templateString} in collection "${collection.name}" but none was found. Possible templates are: ${templateInfo.templates.map((t) => lastItem(t.namespace)).join(" ")}`);
+            }
+            await this.database.put(realPath, {
+              _template: lastItem(template.namespace)
+            });
+        }
+        return this.getDocument(realPath);
+      }
+      const params = this.buildObjectMutations(args.params[collection.name], collection);
+      await this.database.put(realPath, params);
+      return this.getDocument(realPath);
+    };
+    this.updateResolveDocument = async ({
+      collection,
+      realPath,
+      args,
+      isAddPendingDocument,
+      isCollectionSpecific
+    }) => {
+      if (isAddPendingDocument === true) {
         const templateInfo = this.tinaSchema.getTemplatesForCollectable(collection);
-        const params = this.buildParams(args);
+        const params2 = this.buildParams(args);
         switch (templateInfo.type) {
           case "object":
-            if (params) {
-              const values = this.buildFieldMutations(params, templateInfo.template);
+            if (params2) {
+              const values = this.buildFieldMutations(params2, templateInfo.template);
               await this.database.put(realPath, values);
             }
             break;
           case "union":
             await sequential(templateInfo.templates, async (template) => {
-              const templateParams = params[lastItem(template.namespace)];
+              const templateParams = params2[lastItem(template.namespace)];
               if (templateParams) {
                 if (typeof templateParams === "string") {
-                  throw new Error(`Expected to find an objet for template params, but got string`);
+                  throw new Error(`Expected to find an object for template params, but got string`);
                 }
                 const values = __spreadProps(__spreadValues({}, this.buildFieldMutations(templateParams, template)), {
                   _template: lastItem(template.namespace)
@@ -21530,9 +22104,58 @@ var Resolver = class {
               }
             });
         }
+        return this.getDocument(realPath);
       }
+      const params = this.buildObjectMutations(isCollectionSpecific ? args.params : args.params[collection.name], collection);
+      await this.database.put(realPath, params);
       return this.getDocument(realPath);
     };
+    this.resolveDocument = async ({
+      args,
+      collection: collectionName,
+      isMutation,
+      isCreation,
+      isAddPendingDocument,
+      isCollectionSpecific
+    }) => {
+      let collectionLookup = collectionName || void 0;
+      if (!collectionLookup && isCollectionSpecific === false) {
+        collectionLookup = Object.keys(args.params)[0];
+      }
+      const collectionNames = this.tinaSchema.getCollections().map((item) => item.name);
+      assertShape(collectionLookup, (yup3) => {
+        return yup3.mixed().oneOf(collectionNames);
+      }, `"collection" must be one of: [${collectionNames.join(", ")}] but got ${collectionLookup}`);
+      assertShape(args, (yup3) => yup3.object({ relativePath: yup3.string().required() }));
+      const collection = await this.tinaSchema.getCollection(collectionLookup);
+      const realPath = import_path4.default.join(collection == null ? void 0 : collection.path, args.relativePath);
+      const alreadyExists = await this.database.documentExists(realPath);
+      if (isMutation) {
+        if (isCreation) {
+          if (alreadyExists === true) {
+            throw new Error(`Unable to add document, ${realPath} already exists`);
+          }
+          return this.createResolveDocument({
+            collection,
+            realPath,
+            args,
+            isAddPendingDocument
+          });
+        }
+        if (alreadyExists === false) {
+          throw new Error(`Unable to update document, ${realPath} does not exist`);
+        }
+        return this.updateResolveDocument({
+          collection,
+          realPath,
+          args,
+          isAddPendingDocument,
+          isCollectionSpecific
+        });
+      } else {
+        return this.getDocument(realPath);
+      }
+    };
     this.resolveCollectionConnections = async ({ ids }) => {
       return {
         totalCount: ids.length,
@@ -21582,40 +22205,7 @@ var Resolver = class {
             accum[fieldName] = fieldValue;
             break;
           case "object":
-            if (field.fields) {
-              const objectTemplate = typeof field.fields === "string" ? this.tinaSchema.getGlobalTemplate(field.fields) : field;
-              if (Array.isArray(fieldValue)) {
-                accum[fieldName] = fieldValue.map((item) => this.buildFieldMutations(item, objectTemplate));
-              } else {
-                accum[fieldName] = this.buildFieldMutations(fieldValue, objectTemplate);
-              }
-              break;
-            }
-            if (field.templates) {
-              if (Array.isArray(fieldValue)) {
-                accum[fieldName] = fieldValue.map((item) => {
-                  if (typeof item === "string") {
-                    throw new Error(`Expected object for template value for field ${field.name}`);
-                  }
-                  const templates = field.templates.map((templateOrTemplateName) => {
-                    if (typeof templateOrTemplateName === "string") {
-                      return this.tinaSchema.getGlobalTemplate(templateOrTemplateName);
-                    }
-                    return templateOrTemplateName;
-                  });
-                  const [templateName] = Object.entries(item)[0];
-                  const template2 = templates.find((template3) => template3.name === templateName);
-                  if (!template2) {
-                    throw new Error(`Expected to find template ${templateName}`);
-                  }
-                  return __spreadProps(__spreadValues({}, this.buildFieldMutations(item[template2.name], template2)), {
-                    _template: template2.name
-                  });
-                });
-              } else {
-                throw new Error("Not implement for polymorphic objects which are not lists");
-              }
-            }
+            accum[fieldName] = this.buildObjectMutations(fieldValue, field);
             break;
           case "rich-text":
             field;
@@ -21635,7 +22225,7 @@ var Resolver = class {
       if (!rawData) {
         return void 0;
       }
-      assertShape(rawData, (yup2) => yup2.object());
+      assertShape(rawData, (yup3) => yup3.object());
       const value = rawData[field.name];
       switch (field.type) {
         case "string":
@@ -21659,7 +22249,7 @@ var Resolver = class {
             if (!value) {
               return;
             }
-            assertShape(value, (yup2) => yup2.array().of(yup2.object().required()));
+            assertShape(value, (yup3) => yup3.array().of(yup3.object().required()));
             accumulator[field.name] = await sequential(value, async (item) => {
               const template = await this.tinaSchema.getTemplateForData({
                 data: item,
@@ -21703,15 +22293,15 @@ var Resolver = class {
     };
     this.buildParams = (args) => {
       try {
-        assertShape(args, (yup2) => yup2.object({
-          collection: yup2.string().required(),
-          params: yup2.object().required()
+        assertShape(args, (yup3) => yup3.object({
+          collection: yup3.string().required(),
+          params: yup3.object().required()
         }));
         return args.params[args.collection];
       } catch (e) {
       }
-      assertShape(args, (yup2) => yup2.object({
-        params: yup2.object().required()
+      assertShape(args, (yup3) => yup3.object({
+        params: yup3.object().required()
       }));
       return args.params;
     };
@@ -21825,7 +22415,7 @@ var Resolver = class {
             return this.database.getDocumentsForCollection(collectionName);
           }));
           return __spreadValues(__spreadProps(__spreadValues({}, field), {
-            component: "select",
+            component: "reference",
             options: [
               { label: "Choose an option", value: "" },
               ...documents.map((filepath) => {
@@ -21860,28 +22450,28 @@ var resolve = async ({
 }) => {
   try {
     const graphQLSchemaAst = await database.getGraphQLSchema();
-    const graphQLSchema = (0, import_graphql3.buildASTSchema)(graphQLSchemaAst);
+    const graphQLSchema = (0, import_graphql4.buildASTSchema)(graphQLSchemaAst);
     const config = await database.getTinaSchema();
     const tinaSchema = await createSchema({ schema: config });
     const resolver2 = await createResolver2({ database, tinaSchema });
     const paths = [];
     const mutationPaths = [];
-    const ast = (0, import_graphql3.parse)(query);
-    const typeInfo = new import_graphql3.TypeInfo(graphQLSchema);
+    const ast = (0, import_graphql4.parse)(query);
+    const typeInfo = new import_graphql4.TypeInfo(graphQLSchema);
     const referencePathVisitor = () => {
       return {
         leave: {
-          Field(node, key2, parent, path7, ancestors) {
+          Field(node, key2, parent, path8, ancestors) {
             const type = typeInfo.getType();
             if (type) {
-              const realType = (0, import_graphql3.getNamedType)(type);
-              if (realType instanceof import_graphql3.GraphQLUnionType) {
+              const realType = (0, import_graphql4.getNamedType)(type);
+              if (realType instanceof import_graphql4.GraphQLUnionType) {
                 const hasNodeInterface = !!realType.getTypes().find((objectType) => objectType.getInterfaces().find((intfc) => intfc.name === "Node"));
                 if (hasNodeInterface) {
                   const p = [];
                   ancestors.forEach((item, index2) => {
                     var _a;
-                    const activePath = path7[index2];
+                    const activePath = path8[index2];
                     const result = item[activePath];
                     if ((_a = result == null ? void 0 : result.name) == null ? void 0 : _a.value) {
                       if (result.kind === "Field") {
@@ -21903,8 +22493,8 @@ var resolve = async ({
         }
       };
     };
-    (0, import_graphql3.visit)(ast, (0, import_graphql3.visitWithTypeInfo)(typeInfo, referencePathVisitor()));
-    const res = await (0, import_graphql3.graphql)({
+    (0, import_graphql4.visit)(ast, (0, import_graphql4.visitWithTypeInfo)(typeInfo, referencePathVisitor()));
+    const res = await (0, import_graphql4.graphql)({
       schema: graphQLSchema,
       source: query,
       variableValues: variables,
@@ -21914,7 +22504,7 @@ var resolve = async ({
       typeResolver: async (source, _args, info) => {
         if (source.__typename)
           return source.__typename;
-        const namedType = (0, import_graphql3.getNamedType)(info.returnType).toString();
+        const namedType = (0, import_graphql4.getNamedType)(info.returnType).toString();
         const lookup = await database.getLookup(namedType);
         if (lookup.resolveType === "unionData") {
           return lookup.typeMap[source._template];
@@ -21924,7 +22514,7 @@ var resolve = async ({
       },
       fieldResolver: async (source = {}, _args = {}, _context, info) => {
         const args = JSON.parse(JSON.stringify(_args));
-        const returnType = (0, import_graphql3.getNamedType)(info.returnType).toString();
+        const returnType = (0, import_graphql4.getNamedType)(info.returnType).toString();
         const lookup = await database.getLookup(returnType);
         const isMutation = info.parentType.toString() === "Mutation";
         const value = source[info.fieldName];
@@ -21948,7 +22538,7 @@ var resolve = async ({
         const isCreation = lookup[info.fieldName] === "create";
         switch (lookup.resolveType) {
           case "nodeDocument":
-            assertShape(args, (yup2) => yup2.object({ id: yup2.string().required() }));
+            assertShape(args, (yup3) => yup3.object({ id: yup3.string().required() }));
             return resolver2.getDocument(args.id);
           case "multiCollectionDocument":
             if (typeof value === "string") {
@@ -21956,20 +22546,21 @@ var resolve = async ({
             }
             if (args && args.collection && info.fieldName === "addPendingDocument") {
               return resolver2.resolveDocument({
-                value,
                 args: __spreadProps(__spreadValues({}, args), { params: {} }),
                 collection: args.collection,
                 isMutation,
-                isCreation: true
+                isCreation: true,
+                isAddPendingDocument: true
               });
             }
             if (["getDocument", "createDocument", "updateDocument"].includes(info.fieldName)) {
               const result2 = await resolver2.resolveDocument({
-                value,
                 args,
                 collection: args.collection,
                 isMutation,
-                isCreation
+                isCreation,
+                isAddPendingDocument: false,
+                isCollectionSpecific: false
               });
               if (!isMutation) {
                 const mutationPath = buildMutationPath(info, {
@@ -21983,7 +22574,7 @@ var resolve = async ({
             }
             return value;
           case "multiCollectionDocumentList":
-            assertShape(value, (yup2) => yup2.array().of(yup2.string()));
+            assertShape(value, (yup3) => yup3.array().of(yup3.string()));
             return resolver2.resolveCollectionConnections({
               ids: value || []
             });
@@ -21992,11 +22583,12 @@ var resolve = async ({
               return value;
             }
             const result = value || await resolver2.resolveDocument({
-              value,
               args,
               collection: lookup.collection,
               isMutation,
-              isCreation
+              isCreation,
+              isAddPendingDocument: false,
+              isCollectionSpecific: true
             });
             if (!isMutation) {
               const mutationPath = buildMutationPath(info, {
@@ -22032,7 +22624,7 @@ var resolve = async ({
     });
     return res;
   } catch (e) {
-    if (e instanceof import_graphql3.GraphQLError) {
+    if (e instanceof import_graphql4.GraphQLError) {
       return {
         errors: [e]
       };
@@ -22041,17 +22633,17 @@ var resolve = async ({
     }
   }
 };
-var buildPath = (path7, accum) => {
-  if (path7.prev) {
-    buildPath(path7.prev, accum);
+var buildPath = (path8, accum) => {
+  if (path8.prev) {
+    buildPath(path8.prev, accum);
   }
-  accum.push(path7.key);
+  accum.push(path8.key);
   return accum;
 };
-var buildReferenceQuery = (fieldNode, path7) => {
+var buildReferenceQuery = (fieldNode, path8) => {
   if (fieldNode) {
-    const p = path7.map((item) => item === "data" ? "form" : item);
-    const dataPath = path7;
+    const p = path8.map((item) => item === "data" ? "form" : item);
+    const dataPath = path8;
     const newNode = __spreadProps(__spreadValues({}, fieldNode), {
       name: { kind: "Name", value: "node" },
       arguments: [
@@ -22105,7 +22697,7 @@ var buildReferenceQuery = (fieldNode, path7) => {
         selections: [newNode]
       }
     };
-    const queryString = (0, import_graphql3.print)(q);
+    const queryString = (0, import_graphql4.print)(q);
     return {
       path: ["data", ...p.slice(0, -1)],
       dataPath,
@@ -22216,10 +22808,10 @@ function addFragmentsToQuery(info, fieldNode, q) {
       subFrags: []
     };
     frags.push(frag);
-    (0, import_graphql3.visit)(fragmentDefinition, fragmentSpreadVisitor(frag));
+    (0, import_graphql4.visit)(fragmentDefinition, fragmentSpreadVisitor(frag));
   });
   const n = {
-    query: (0, import_graphql3.print)(fieldNode),
+    query: (0, import_graphql4.print)(fieldNode),
     fragments: []
   };
   const visitor = {
@@ -22229,7 +22821,7 @@ function addFragmentsToQuery(info, fieldNode, q) {
       }
     }
   };
-  (0, import_graphql3.visit)(fieldNode, visitor);
+  (0, import_graphql4.visit)(fieldNode, visitor);
   const getFrags = (fragNames, accum) => {
     fragNames.forEach((fragName) => {
       const frag = frags.find((f) => f.name === fragName);
@@ -22244,73 +22836,30 @@ function addFragmentsToQuery(info, fieldNode, q) {
     return accum;
   };
   const fragss = getFrags(n.fragments, []);
-  const queryString = `${fragss.map((f) => (0, import_graphql3.print)(f)).join("\n")}
-${(0, import_graphql3.print)(q)}`;
+  const queryString = `${fragss.map((f) => (0, import_graphql4.print)(f)).join("\n")}
+${(0, import_graphql4.print)(q)}`;
   return queryString;
 }
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/index.ts
-var import_graphql5 = __toModule(require("graphql"));
-
-// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/cache/lru.ts
-var import_lru_cache2 = __toModule(require("lru-cache"));
-var cache2 = new import_lru_cache2.default({
-  max: 1e3,
-  length: function(v, key2) {
-    return v.length;
-  }
-});
-var clearCache = ({
-  owner,
-  repo,
-  ref,
-  path: path7
-}) => {
-  const repoPrefix = `${owner}/${repo}/${ref}/`;
-  if (path7) {
-    const key2 = `${repoPrefix}/${path7}`;
-    console.log("[LRU cache]: clearing key ", key2);
-    cache2.del(key2);
-  } else {
-    console.log("[LRU cache]: clearing all keys for repo ", repoPrefix);
-    cache2.forEach((value, key2, cache3) => {
-      if (key2.startsWith(repoPrefix)) {
-        cache3.del(key2);
-      }
-    });
-  }
-};
-var simpleCache2 = {
-  get: async (keyName, setter) => {
-    const value = cache2.get(keyName);
-    if (value) {
-      console.log("getting from cache", keyName);
-      return value;
-    } else {
-      const valueToCache = await setter();
-      const isSet = cache2.set(keyName, valueToCache);
-      console.log("item not in cache, setting", keyName, isSet);
-      return valueToCache;
-    }
-  }
-};
+var import_graphql6 = __toModule(require("graphql"));
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/database/index.ts
 var import_gray_matter = __toModule(require("gray-matter"));
-var import_path5 = __toModule(require("path"));
+var import_path6 = __toModule(require("path"));
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/database/bridge.ts
-var import_fs_extra = __toModule(require("fs-extra"));
+var import_fs_extra2 = __toModule(require("fs-extra"));
 var import_fast_glob = __toModule(require("fast-glob"));
-var import_path4 = __toModule(require("path"));
+var import_path5 = __toModule(require("path"));
 var import_normalize_path = __toModule(require("normalize-path"));
 var FilesystemBridge = class {
   constructor(rootPath) {
     this.rootPath = rootPath || "";
   }
   async glob(pattern) {
-    const basePath = import_path4.default.join(this.rootPath, ...pattern.split("/"));
-    const items = await (0, import_fast_glob.default)(import_path4.default.join(basePath, "**", "/*").replace(/\\/g, "/"), {
+    const basePath = import_path5.default.join(this.rootPath, ...pattern.split("/"));
+    const items = await (0, import_fast_glob.default)(import_path5.default.join(basePath, "**", "/*").replace(/\\/g, "/"), {
       dot: true
     });
     const posixRootPath = (0, import_normalize_path.default)(this.rootPath);
@@ -22319,20 +22868,20 @@ var FilesystemBridge = class {
     });
   }
   async get(filepath) {
-    return import_fs_extra.default.readFileSync(import_path4.default.join(this.rootPath, filepath)).toString();
+    return import_fs_extra2.default.readFileSync(import_path5.default.join(this.rootPath, filepath)).toString();
   }
   async put(filepath, data) {
-    await import_fs_extra.default.outputFileSync(import_path4.default.join(this.rootPath, filepath), data);
+    await import_fs_extra2.default.outputFileSync(import_path5.default.join(this.rootPath, filepath), data);
   }
 };
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/primitives/database/index.ts
-var import_graphql4 = __toModule(require("graphql"));
+var import_graphql5 = __toModule(require("graphql"));
 var createDatabase = async (config) => {
   return new Database(config);
 };
 var SYSTEM_FILES = ["_schema", "_graphql", "_lookup"];
-var GENERATED_FOLDER = import_path5.default.join(".tina", "__generated__");
+var GENERATED_FOLDER = import_path6.default.join(".tina", "__generated__");
 var Database = class {
   constructor(config) {
     this.config = config;
@@ -22340,20 +22889,20 @@ var Database = class {
       var _a;
       if (SYSTEM_FILES.includes(filepath)) {
         try {
-          const dataString = await this.bridge.get(import_path5.default.join(GENERATED_FOLDER, `${filepath}.json`));
+          const dataString = await this.bridge.get(import_path6.default.join(GENERATED_FOLDER, `${filepath}.json`));
           return JSON.parse(dataString);
         } catch (err) {
-          if (err instanceof import_graphql4.GraphQLError && ((_a = err.extensions) == null ? void 0 : _a.status) === 404) {
-            throw new import_graphql4.GraphQLError(`${err.toString()}.  Please confirm this location is correct and contains a '.tina' folder and a valid '.tina/schema.ts'.`);
+          if (err instanceof import_graphql5.GraphQLError && ((_a = err.extensions) == null ? void 0 : _a.status) === 404) {
+            throw new import_graphql5.GraphQLError(`${err.toString()}.  Please confirm this location is correct and contains a '.tina' folder and a valid '.tina/schema.ts'.`);
           } else {
             throw err;
           }
         }
       } else {
         const tinaSchema = await this.getSchema();
-        const extension2 = import_path5.default.extname(filepath);
+        const extension2 = import_path6.default.extname(filepath);
         const contentString = await this.bridge.get(filepath);
-        const contentObject = this.parseFile(contentString, extension2, (yup2) => yup2.object({}));
+        const contentObject = this.parseFile(contentString, extension2, (yup3) => yup3.object({}));
         const templateName = hasOwnProperty2(contentObject, "_template") && typeof contentObject._template === "string" ? contentObject._template : void 0;
         const { collection, template } = await tinaSchema.getCollectionAndTemplateByFullPath(filepath, templateName);
         const field = template.fields.find((field2) => {
@@ -22382,7 +22931,7 @@ var Database = class {
     };
     this.put = async (filepath, data) => {
       if (SYSTEM_FILES.includes(filepath)) {
-        await this.bridge.put(import_path5.default.join(GENERATED_FOLDER, `${filepath}.json`), JSON.stringify(data, null, 2));
+        await this.bridge.put(import_path6.default.join(GENERATED_FOLDER, `${filepath}.json`), JSON.stringify(data, null, 2));
       } else {
         const tinaSchema = await this.getSchema();
         const collection = await tinaSchema.getCollectionByFullPath(filepath);
@@ -22420,7 +22969,7 @@ var Database = class {
         } else {
           payload = data;
         }
-        const extension2 = import_path5.default.extname(filepath);
+        const extension2 = import_path6.default.extname(filepath);
         const stringData = this.stringifyFile(payload, extension2, templateInfo.type === "union");
         await this.bridge.put(filepath, stringData);
       }
@@ -22553,19 +23102,16 @@ var githubRoute = async (_a) => {
     rootPath = "",
     query,
     variables,
-    cacheType = simpleCache2,
     branch
   } = _b, githubArgs = __objRest(_b, [
     "rootPath",
     "query",
     "variables",
-    "cacheType",
     "branch"
   ]);
   const gh = new GithubBridge(__spreadValues({
     rootPath,
-    ref: branch,
-    cache: cacheType
+    ref: branch
   }, githubArgs));
   const database = await createDatabase({
     bridge: gh
@@ -22577,74 +23123,14 @@ var githubRoute = async (_a) => {
   });
 };
 var buildSchema = async (rootPath) => {
-  const config = await import_fs_extra2.default.readFileSync(import_path6.default.join(rootPath, ".tina", "__generated__", "config", "schema.json")).toString();
+  const config = await import_fs_extra3.default.readFileSync(import_path7.default.join(rootPath, ".tina", "__generated__", "config", "schema.json")).toString();
   const database = await createDatabase({
     rootPath
   });
   await indexDB({ database, config: JSON.parse(config) });
   const gqlAst = await database.getGraphQLSchema();
-  return (0, import_graphql5.buildASTSchema)(gqlAst);
-};
-
-// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/cache/s3.ts
-var import_aws_sdk = __toModule(require("aws-sdk"));
-var bucketName = process.env.CACHE_S3_BUCKET_NAME || "tina-contentapi";
-var realCache = new import_aws_sdk.S3();
-var clearCacheWith = (cache3) => async ({
-  owner,
-  repo,
-  ref,
-  path: path7
-}) => {
-  const repoPrefix = `${owner}/${repo}/${ref}`;
-  if (path7) {
-    const key2 = `${repoPrefix}/${path7}`;
-    console.log("[S3 cache]: clearing key ", key2);
-    await cache3.deleteObject({
-      Bucket: bucketName,
-      Key: key2
-    }).promise();
-  } else {
-    console.log("[S3 cache]: clearing all keys for repo ", repoPrefix);
-    const data = await cache3.listObjectsV2({
-      Bucket: bucketName,
-      Prefix: repoPrefix
-    }).promise();
-    if (data.Contents) {
-      await cache3.deleteObjects({
-        Bucket: bucketName,
-        Delete: {
-          Objects: data.Contents.map((key2) => ({ Key: key2.Key }))
-        }
-      }).promise();
-    }
-  }
+  return (0, import_graphql6.buildASTSchema)(gqlAst);
 };
-var s3CacheWith = (cache3) => ({
-  get: async (keyName, setter) => {
-    try {
-      const value = await cache3.getObject({
-        Bucket: bucketName,
-        Key: keyName
-      }).promise();
-      console.log("getting from cache", keyName);
-      return value.Body;
-    } catch (error) {
-      if (error.code != "NoSuchKey")
-        throw error;
-      const valueToCache = await setter();
-      await cache3.upload({
-        Bucket: bucketName,
-        Key: keyName,
-        Body: valueToCache.toString()
-      }).promise();
-      console.log("item not in cache, setting", keyName);
-      return valueToCache;
-    }
-  }
-});
-var clearCache2 = clearCacheWith(realCache);
-var s3Cache = s3CacheWith(realCache);
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/index.ts
 var import_rest2 = __toModule(require("@octokit/rest"));
@@ -22676,18 +23162,13 @@ var createBranch = async ({ auth, owner, repo, name, baseBranch }) => {
 0 && (module.exports = {
   GithubBridge,
   buildSchema,
-  clearCache,
   createBranch,
   createDatabase,
   githubRoute,
   gql,
   indexDB,
   listBranches,
-  lruClearCache,
-  resolve,
-  s3Cache,
-  s3ClearCache,
-  simpleCache
+  resolve
 });
 /*!
  * Determine if an object is a Buffer