@tinacms/graphql 0.0.0-e0ddb8c-20241004065742 → 0.0.0-e5c0e91-20250421003142

package/dist/index.mjs

@@ -68,6 +68,15 @@ var SysFieldDefinition = {
   selectionSet: {
     kind: "SelectionSet",
     selections: [
+      // {
+      //   kind: 'Field' as const,
+      //   name: {
+      //     kind: 'Name' as const,
+      //     value: 'title',
+      //   },
+      //   arguments: [],
+      //   directives: [],
+      // },
       {
         kind: "Field",
         name: {
@@ -86,6 +95,15 @@ var SysFieldDefinition = {
         arguments: [],
         directives: []
       },
+      {
+        kind: "Field",
+        name: {
+          kind: "Name",
+          value: "hasReferences"
+        },
+        arguments: [],
+        directives: []
+      },
       {
         kind: "Field",
         name: {
@@ -126,6 +144,10 @@ var SysFieldDefinition = {
   }
 };
 var astBuilder = {
+  /**
+   * `FormFieldBuilder` acts as a shortcut to building an entire `ObjectTypeDefinition`, we use this
+   * because all Tina field objects share a common set of fields ('name', 'label', 'component')
+   */
   FormFieldBuilder: ({
     name,
     additionalFields
@@ -349,6 +371,8 @@ var astBuilder = {
       kind: "Name",
       value: name
     },
+    // @ts-ignore FIXME; this is being handled properly but we're lying to
+    // ts and then fixing it in the `extractInlineTypes` function
     fields
   }),
   UnionTypeDefinition: ({
@@ -361,6 +385,8 @@ var astBuilder = {
       value: name
     },
     directives: [],
+    // @ts-ignore FIXME; this is being handled properly but we're lying to
+    // ts and then fixing it in the `extractInlineTypes` function
     types: types.map((name2) => ({
       kind: "NamedType",
       name: {
@@ -457,8 +483,11 @@ var astBuilder = {
         string: "String",
         boolean: "Boolean",
         number: "Float",
+        // FIXME - needs to be float or int
         datetime: "String",
+        // FIXME
         image: "String",
+        // FIXME
         text: "String"
       };
       return scalars[type];
@@ -957,8 +986,7 @@ var astBuilder = {
   }
 };
 var capitalize = (s) => {
-  if (typeof s !== "string")
-    return "";
+  if (typeof s !== "string") return "";
   return s.charAt(0).toUpperCase() + s.slice(1);
 };
 var extractInlineTypes = (item) => {
@@ -1001,41 +1029,6 @@ function* walk(maybeNode, visited = /* @__PURE__ */ new WeakSet()) {
   yield maybeNode;
   visited.add(maybeNode);
 }
-function addNamespaceToSchema(maybeNode, namespace = []) {
-  if (typeof maybeNode === "string") {
-    return maybeNode;
-  }
-  if (typeof maybeNode === "boolean") {
-    return maybeNode;
-  }
-  const newNode = maybeNode;
-  const keys = Object.keys(maybeNode);
-  Object.values(maybeNode).map((m, index) => {
-    const key = keys[index];
-    if (Array.isArray(m)) {
-      newNode[key] = m.map((element) => {
-        if (!element) {
-          return;
-        }
-        if (!element.hasOwnProperty("name")) {
-          return element;
-        }
-        const value = element.name || element.value;
-        return addNamespaceToSchema(element, [...namespace, value]);
-      });
-    } else {
-      if (!m) {
-        return;
-      }
-      if (!m.hasOwnProperty("name")) {
-        newNode[key] = m;
-      } else {
-        newNode[key] = addNamespaceToSchema(m, [...namespace, m.name]);
-      }
-    }
-  });
-  return { ...newNode, namespace };
-}
 var generateNamespacedFieldName = (names, suffix = "") => {
   return (suffix ? [...names, suffix] : names).map(capitalize).join("");
 };
@@ -1195,6 +1188,11 @@ var scalarDefinitions = [
         required: true,
         type: astBuilder.TYPES.String
       }),
+      astBuilder.FieldDefinition({
+        name: "hasReferences",
+        required: false,
+        type: astBuilder.TYPES.Boolean
+      }),
       astBuilder.FieldDefinition({
         name: "breadcrumbs",
         required: true,
@@ -1408,6 +1406,19 @@ var Builder = class {
     this.addToLookupMap = (lookup) => {
       this.lookupMap[lookup.type] = lookup;
     };
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getCollection(collection: $collection) {
+     *     name
+     *     documents {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
     this.buildCollectionDefinition = async (collections) => {
       const name = "collection";
       const typeName = "Collection";
@@ -1478,6 +1489,19 @@ var Builder = class {
         required: true
       });
     };
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getCollections {
+     *     name
+     *     documents {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
     this.buildMultiCollectionDefinition = async (collections) => {
       const name = "collections";
       const typeName = "Collection";
@@ -1488,6 +1512,17 @@ var Builder = class {
         required: true
       });
     };
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   node(id: $id) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     */
     this.multiNodeDocument = async () => {
       const name = "node";
       const args = [
@@ -1508,6 +1543,19 @@ var Builder = class {
         required: true
       });
     };
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getDocument(collection: $collection, relativePath: $relativePath) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
     this.multiCollectionDocument = async (collections) => {
       const name = "document";
       const args = [
@@ -1533,6 +1581,19 @@ var Builder = class {
         required: true
       });
     };
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   addPendingDocument(collection: $collection, relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
     this.addMultiCollectionDocumentMutation = async () => {
       return astBuilder.FieldDefinition({
         name: "addPendingDocument",
@@ -1557,6 +1618,19 @@ var Builder = class {
         type: astBuilder.TYPES.MultiCollectionDocument
       });
     };
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   createDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
     this.buildCreateCollectionDocumentMutation = async (collections) => {
       return astBuilder.FieldDefinition({
         name: "createDocument",
@@ -1584,6 +1658,19 @@ var Builder = class {
         type: astBuilder.TYPES.MultiCollectionDocument
       });
     };
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   updateDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
     this.buildUpdateCollectionDocumentMutation = async (collections) => {
       return astBuilder.FieldDefinition({
         name: "updateDocument",
@@ -1611,6 +1698,19 @@ var Builder = class {
         type: astBuilder.TYPES.MultiCollectionDocument
       });
     };
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   deleteDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
     this.buildDeleteCollectionDocumentMutation = async (collections) => {
       return astBuilder.FieldDefinition({
         name: "deleteDocument",
@@ -1630,6 +1730,19 @@ var Builder = class {
         type: astBuilder.TYPES.MultiCollectionDocument
       });
     };
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   createFolder(folderName: $folderName, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
     this.buildCreateCollectionFolderMutation = async () => {
       return astBuilder.FieldDefinition({
         name: "createFolder",
@@ -1649,6 +1762,19 @@ var Builder = class {
         type: astBuilder.TYPES.MultiCollectionDocument
       });
     };
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getPostDocument(relativePath: $relativePath) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
     this.collectionDocument = async (collection) => {
       const name = NAMER.queryName([collection.name]);
       const type = await this._buildCollectionDocumentType(collection);
@@ -1709,6 +1835,20 @@ var Builder = class {
       const args = [];
       return astBuilder.FieldDefinition({ type, name, args, required: false });
     };
+    /**
+     * Turns a collection into a fragment that gets updated on build. This fragment does not resolve references
+     * ```graphql
+     * # ex.
+     * fragment AuthorsParts on Authors {
+     *   name
+     *   avatar
+     *   ...
+     * }
+     * ```
+     *
+     * @public
+     * @param collection a TinaCloud collection
+     */
     this.collectionFragment = async (collection) => {
       const name = NAMER.dataTypeName(collection.namespace);
       const fragmentName = NAMER.fragmentName(collection.namespace);
@@ -1722,6 +1862,20 @@ var Builder = class {
         selections: filterSelections(selections)
       });
     };
+    /**
+     * Given a collection this function returns its selections set. For example for Post this would return
+     *
+     * "
+     * body
+     * title
+     * ... on Author {
+     *   name
+     *   heroImg
+     * }
+     *
+     * But in the AST format
+     *
+     * */
     this._getCollectionFragmentSelections = async (collection, depth) => {
       const selections = [];
       selections.push({
@@ -1803,9 +1957,9 @@ var Builder = class {
               ]
             });
           }
+        // TODO: Should we throw here?
         case "reference":
-          if (depth >= this.maxDepth)
-            return false;
+          if (depth >= this.maxDepth) return false;
           if (!("collections" in field)) {
             return false;
           }
@@ -1837,6 +1991,7 @@ var Builder = class {
             name: field.name,
             selections: [
               ...selections,
+              // This is ... on Document { id }
               {
                 kind: "InlineFragment",
                 typeCondition: {
@@ -1867,6 +2022,19 @@ var Builder = class {
           });
       }
     };
+    /**
+     * ```graphql
+     * # ex.
+     * mutation {
+     *   updatePostDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
     this.updateCollectionDocumentMutation = async (collection) => {
       return astBuilder.FieldDefinition({
         type: await this._buildCollectionDocumentType(collection),
@@ -1886,6 +2054,19 @@ var Builder = class {
         ]
       });
     };
+    /**
+     * ```graphql
+     * # ex.
+     * mutation {
+     *   createPostDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
     this.createCollectionDocumentMutation = async (collection) => {
       return astBuilder.FieldDefinition({
         type: await this._buildCollectionDocumentType(collection),
@@ -1905,6 +2086,22 @@ var Builder = class {
         ]
       });
     };
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getPostList(first: 10) {
+     *     edges {
+     *       node {
+     *         id
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
     this.collectionDocumentList = async (collection) => {
       const connectionName = NAMER.referenceConnectionType(collection.namespace);
       this.addToLookupMap({
@@ -1920,6 +2117,10 @@ var Builder = class {
         collection
       });
     };
+    /**
+     * GraphQL type definitions which remain unchanged regardless
+     * of the supplied Tina schema. Ex. "node" interface
+     */
     this.buildStaticDefinitions = () => staticDefinitions;
     this._buildCollectionDocumentType = async (collection, suffix = "", extraFields = [], extraInterfaces = []) => {
       const documentTypeName = NAMER.documentTypeName(collection.namespace);
@@ -2424,6 +2625,7 @@ var Builder = class {
             name: NAMER.dataFilterTypeName(namespace),
             fields: await sequential(collections, async (collection2) => {
               return astBuilder.InputValueDefinition({
+                // @ts-ignore
                 name: collection2.name,
                 type: NAMER.dataFilterTypeName(collection2.namespace)
               });
@@ -2612,7 +2814,8 @@ Visit https://tina.io/docs/errors/ui-not-supported/ for more information
         ]
       });
     };
-    this.maxDepth = config?.tinaSchema.schema?.config?.client?.referenceDepth ?? 2;
+    this.maxDepth = // @ts-ignore
+    config?.tinaSchema.schema?.config?.client?.referenceDepth ?? 2;
     this.tinaSchema = config.tinaSchema;
     this.lookupMap = {};
   }
@@ -2623,8 +2826,7 @@ Visit https://tina.io/docs/errors/ui-not-supported/ for more information
       selections.push(field);
     });
     const filteredSelections = filterSelections(selections);
-    if (!filteredSelections.length)
-      return false;
+    if (!filteredSelections.length) return false;
     return astBuilder.InlineFragmentDefinition({
       selections: filteredSelections,
       name: NAMER.dataTypeName(template.namespace)
@@ -2661,6 +2863,7 @@ var filterSelections = (arr) => {
 import { TinaSchema } from "@tinacms/schema-tools";
 
 // src/schema/validate.ts
+import { addNamespaceToSchema } from "@tinacms/schema-tools";
 import deepClone from "lodash.clonedeep";
 import * as yup2 from "yup";
 import {
@@ -2707,6 +2910,7 @@ var validationCollectionsPathAndMatch = (collections) => {
   }).map((x) => `${x.path}${x.format || "md"}`);
   if (noMatchCollections.length !== new Set(noMatchCollections).size) {
     throw new Error(
+      // TODO: add a link to the docs
       "Two collections without match can not have the same `path`. Please make the `path` unique or add a matches property to the collection."
     );
   }
@@ -2815,7 +3019,7 @@ var validateField = async (field) => {
 // package.json
 var package_default = {
   name: "@tinacms/graphql",
-  version: "1.5.4",
+  version: "1.5.16",
   main: "dist/index.js",
   module: "dist/index.mjs",
   typings: "dist/index.d.ts",
@@ -2842,8 +3046,8 @@ var package_default = {
     build: "tinacms-scripts build",
     docs: "pnpm typedoc",
     serve: "pnpm nodemon dist/server.js",
-    test: "jest",
-    "test-watch": "jest --watch"
+    test: "vitest run",
+    "test-watch": "vitest"
   },
   dependencies: {
     "@iarna/toml": "^2.2.5",
@@ -2851,22 +3055,22 @@ var package_default = {
     "@tinacms/schema-tools": "workspace:*",
     "abstract-level": "^1.0.4",
     "date-fns": "^2.30.0",
-    "fast-glob": "^3.3.2",
-    "fs-extra": "^11.2.0",
+    "fast-glob": "^3.3.3",
+    "fs-extra": "^11.3.0",
     "glob-parent": "^6.0.2",
     graphql: "15.8.0",
     "gray-matter": "^4.0.3",
-    "isomorphic-git": "^1.27.1",
+    "isomorphic-git": "^1.29.0",
     "js-sha1": "^0.6.0",
     "js-yaml": "^3.14.1",
-    "jsonpath-plus": "^6.0.1",
+    "jsonpath-plus": "10.1.0",
     "lodash.clonedeep": "^4.5.0",
     "lodash.set": "^4.3.2",
     "lodash.uniqby": "^4.7.0",
     "many-level": "^2.0.0",
     micromatch: "4.0.8",
     "normalize-path": "^3.0.0",
-    "readable-stream": "^4.5.2",
+    "readable-stream": "^4.7.0",
     scmp: "^2.1.0",
     yup: "^0.32.11"
   },
@@ -2884,24 +3088,23 @@ var package_default = {
     "@types/estree": "^0.0.50",
     "@types/express": "^4.17.21",
     "@types/fs-extra": "^9.0.13",
-    "@types/jest": "^26.0.24",
     "@types/js-yaml": "^3.12.10",
     "@types/lodash.camelcase": "^4.3.9",
     "@types/lodash.upperfirst": "^4.3.9",
     "@types/lru-cache": "^5.1.1",
     "@types/mdast": "^3.0.15",
     "@types/micromatch": "^4.0.9",
-    "@types/node": "^22.7.4",
+    "@types/node": "^22.13.1",
     "@types/normalize-path": "^3.0.2",
     "@types/ws": "^7.4.7",
     "@types/yup": "^0.29.14",
-    jest: "^29.7.0",
-    "jest-diff": "^29.7.0",
     "jest-file-snapshot": "^0.5.0",
-    "jest-matcher-utils": "^29.7.0",
     "memory-level": "^1.0.0",
     nodemon: "3.1.4",
-    typescript: "^5.6.2"
+    typescript: "^5.7.3",
+    vite: "^4.5.9",
+    vitest: "^0.32.4",
+    zod: "^3.24.2"
   }
 };
 
@@ -2972,6 +3175,7 @@ var _buildFragments = async (builder, tinaSchema) => {
   const fragDoc = {
     kind: "Document",
     definitions: uniqBy2(
+      // @ts-ignore
       extractInlineTypes(fragmentDefinitionsFields),
       (node) => node.name.value
     )
@@ -2994,6 +3198,7 @@ var _buildQueries = async (builder, tinaSchema) => {
         fragName,
         queryName: queryListName,
         filterType: queryFilterTypeName,
+        // look for flag to see if the data layer is enabled
         dataLayer: Boolean(
           tinaSchema.config?.meta?.flags?.find((x) => x === "experimentalData")
         )
@@ -3003,6 +3208,7 @@ var _buildQueries = async (builder, tinaSchema) => {
   const queryDoc = {
     kind: "Document",
     definitions: uniqBy2(
+      // @ts-ignore
       extractInlineTypes(operationsDefinitions),
       (node) => node.name.value
     )
@@ -3054,7 +3260,9 @@ var _buildSchema = async (builder, tinaSchema) => {
     await builder.buildCreateCollectionFolderMutation()
   );
   await sequential(collections, async (collection) => {
-    queryTypeDefinitionFields.push(await builder.collectionDocument(collection));
+    queryTypeDefinitionFields.push(
+      await builder.collectionDocument(collection)
+    );
     if (collection.isAuthCollection) {
       queryTypeDefinitionFields.push(
         await builder.authenticationCollectionDocument(collection)
@@ -3091,6 +3299,7 @@ var _buildSchema = async (builder, tinaSchema) => {
   return {
     kind: "Document",
     definitions: uniqBy2(
+      // @ts-ignore
       extractInlineTypes(definitions),
       (node) => node.name.value
     )
@@ -3107,6 +3316,9 @@ import isValid from "date-fns/isValid/index.js";
 // src/mdx/index.ts
 import { parseMDX, stringifyMDX } from "@tinacms/mdx";
 
+// src/resolver/index.ts
+import { JSONPath as JSONPath2 } from "jsonpath-plus";
+
 // src/resolver/error.ts
 var TinaGraphQLError = class extends Error {
   constructor(message, extensions) {
@@ -3292,8 +3504,7 @@ var resolveMediaCloudToRelative = (value, config = { useRelativeMedia: true }, s
       }
       if (Array.isArray(value)) {
         return value.map((v) => {
-          if (!v || typeof v !== "string")
-            return v;
+          if (!v || typeof v !== "string") return v;
           const cleanMediaRoot = cleanUpSlashes(
             schema.config.media.tina.mediaRoot
           );
@@ -3321,8 +3532,7 @@ var resolveMediaRelativeToCloud = (value, config = { useRelativeMedia: true }, s
       }
       if (Array.isArray(value)) {
         return value.map((v) => {
-          if (!v || typeof v !== "string")
-            return v;
+          if (!v || typeof v !== "string") return v;
           const strippedValue = v.replace(cleanMediaRoot, "");
           return `https://${config.assetsHost}/${config.clientId}${strippedValue}`;
         });
@@ -3340,8 +3550,7 @@ var cleanUpSlashes = (path7) => {
   return "";
 };
 var hasTinaMediaConfig = (schema) => {
-  if (!schema.config?.media?.tina)
-    return false;
+  if (!schema.config?.media?.tina) return false;
   if (typeof schema.config?.media?.tina?.publicFolder !== "string" && typeof schema.config?.media?.tina?.mediaRoot !== "string")
     return false;
   return true;
@@ -3368,7 +3577,9 @@ var LevelProxyHandler = {
       throw new Error(`The property, ${property.toString()}, doesn't exist`);
     }
     if (typeof target[property] !== "function") {
-      throw new Error(`The property, ${property.toString()}, is not a function`);
+      throw new Error(
+        `The property, ${property.toString()}, is not a function`
+      );
     }
     if (property === "get") {
       return async (...args) => {
@@ -3385,6 +3596,7 @@ var LevelProxyHandler = {
     } else if (property === "sublevel") {
       return (...args) => {
         return new Proxy(
+          // eslint-disable-next-line prefer-spread
           target[property].apply(target, args),
           LevelProxyHandler
         );
@@ -3752,6 +3964,9 @@ var loadAndParseWithAliases = async (bridge, filepath, collection, templateInfo)
 
 // src/database/datalayer.ts
 var DEFAULT_COLLECTION_SORT_KEY = "__filepath__";
+var REFS_COLLECTIONS_SORT_KEY = "__refs__";
+var REFS_REFERENCE_FIELD = "__tina_ref__";
+var REFS_PATH_FIELD = "__tina_ref_path__";
 var DEFAULT_NUMERIC_LPAD = 4;
 var applyPadding = (input, pad) => {
   if (pad) {
@@ -4261,6 +4476,7 @@ var makeFolderOpsForCollection = (folderTree, collection, indexDefinitions, opTy
           result.push({
             type: opType,
             key: `${collection.path}/${subFolderKey}.${collection.format}`,
+            // replace the root with the collection path
             sublevel: indexSublevel,
             value: {}
           });
@@ -4324,6 +4540,57 @@ var makeIndexOpsForDocument = (filepath, collection, indexDefinitions, data, opT
   }
   return result;
 };
+var makeRefOpsForDocument = (filepath, collection, references, data, opType, level) => {
+  const result = [];
+  if (collection) {
+    for (const [c, referencePaths] of Object.entries(references || {})) {
+      if (!referencePaths.length) {
+        continue;
+      }
+      const collectionSublevel = level.sublevel(c, SUBLEVEL_OPTIONS);
+      const refSublevel = collectionSublevel.sublevel(
+        REFS_COLLECTIONS_SORT_KEY,
+        SUBLEVEL_OPTIONS
+      );
+      const references2 = {};
+      for (const path7 of referencePaths) {
+        const ref = JSONPath({ path: path7, json: data });
+        if (!ref) {
+          continue;
+        }
+        if (Array.isArray(ref)) {
+          for (const r of ref) {
+            if (!r) {
+              continue;
+            }
+            if (references2[r]) {
+              references2[r].push(path7);
+            } else {
+              references2[r] = [path7];
+            }
+          }
+        } else {
+          if (references2[ref]) {
+            references2[ref].push(path7);
+          } else {
+            references2[ref] = [path7];
+          }
+        }
+      }
+      for (const ref of Object.keys(references2)) {
+        for (const path7 of references2[ref]) {
+          result.push({
+            type: opType,
+            key: `${ref}${INDEX_KEY_FIELD_SEPARATOR}${path7}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`,
+            sublevel: refSublevel,
+            value: opType === "put" ? {} : void 0
+          });
+        }
+      }
+    }
+  }
+  return result;
+};
 var makeStringEscaper = (regex, replacement) => {
   return (input) => {
     if (Array.isArray(input)) {
@@ -4375,6 +4642,7 @@ var resolveFieldData = async ({ namespace, ...field }, rawData, accumulator, tin
     case "password":
       accumulator[field.name] = {
         value: void 0,
+        // never resolve the password hash
         passwordChangeRequired: value["passwordChangeRequired"] ?? false
       };
       break;
@@ -4469,7 +4737,7 @@ var resolveFieldData = async ({ namespace, ...field }, rawData, accumulator, tin
   }
   return accumulator;
 };
-var transformDocumentIntoPayload = async (fullPath, rawData, tinaSchema, config, isAudit) => {
+var transformDocumentIntoPayload = async (fullPath, rawData, tinaSchema, config, isAudit, hasReferences) => {
   const collection = tinaSchema.getCollection(rawData._collection);
   try {
     const template = tinaSchema.getTemplateForData({
@@ -4523,6 +4791,7 @@ var transformDocumentIntoPayload = async (fullPath, rawData, tinaSchema, config,
         basename,
         filename,
         extension,
+        hasReferences,
         path: fullPath,
         relativePath,
         breadcrumbs,
@@ -4542,6 +4811,34 @@ var transformDocumentIntoPayload = async (fullPath, rawData, tinaSchema, config,
     throw e;
   }
 };
+var updateObjectWithJsonPath = (obj, path7, oldValue, newValue) => {
+  let updated = false;
+  if (!path7.includes(".") && !path7.includes("[")) {
+    if (path7 in obj && obj[path7] === oldValue) {
+      obj[path7] = newValue;
+      updated = true;
+    }
+    return { object: obj, updated };
+  }
+  const parentPath = path7.replace(/\.[^.\[\]]+$/, "");
+  const keyToUpdate = path7.match(/[^.\[\]]+$/)[0];
+  const parents = JSONPath2({
+    path: parentPath,
+    json: obj,
+    resultType: "value"
+  });
+  if (parents.length > 0) {
+    parents.forEach((parent) => {
+      if (parent && typeof parent === "object" && keyToUpdate in parent) {
+        if (parent[keyToUpdate] === oldValue) {
+          parent[keyToUpdate] = newValue;
+          updated = true;
+        }
+      }
+    });
+  }
+  return { object: obj, updated };
+};
 var Resolver = class {
   constructor(init) {
     this.init = init;
@@ -4549,6 +4846,7 @@ var Resolver = class {
       const collection = this.tinaSchema.getCollection(collectionName);
       const extraFields = {};
       return {
+        // return the collection and hasDocuments to resolve documents at a lower level
         documents: { collection, hasDocuments },
         ...collection,
         ...extraFields
@@ -4556,7 +4854,9 @@ var Resolver = class {
     };
     this.getRaw = async (fullPath) => {
       if (typeof fullPath !== "string") {
-        throw new Error(`fullPath must be of type string for getDocument request`);
+        throw new Error(
+          `fullPath must be of type string for getDocument request`
+        );
       }
       return this.database.get(fullPath);
     };
@@ -4583,22 +4883,28 @@ var Resolver = class {
         );
       }
     };
-    this.getDocument = async (fullPath) => {
+    this.getDocument = async (fullPath, opts = {}) => {
       if (typeof fullPath !== "string") {
-        throw new Error(`fullPath must be of type string for getDocument request`);
+        throw new Error(
+          `fullPath must be of type string for getDocument request`
+        );
       }
       const rawData = await this.getRaw(fullPath);
+      const hasReferences = opts?.checkReferences ? await this.hasReferences(fullPath, opts.collection) : void 0;
       return transformDocumentIntoPayload(
         fullPath,
         rawData,
         this.tinaSchema,
         this.config,
-        this.isAudit
+        this.isAudit,
+        hasReferences
       );
     };
     this.deleteDocument = async (fullPath) => {
       if (typeof fullPath !== "string") {
-        throw new Error(`fullPath must be of type string for getDocument request`);
+        throw new Error(
+          `fullPath must be of type string for getDocument request`
+        );
       }
       await this.database.delete(fullPath);
     };
@@ -4633,7 +4939,9 @@ var Resolver = class {
           );
         } else {
           return this.buildFieldMutations(
+            // @ts-ignore FIXME Argument of type 'string | object' is not assignable to parameter of type '{ [fieldName: string]: string | object | (string | object)[]; }'
             fieldValue,
+            //@ts-ignore
             objectTemplate,
             existingData
           );
@@ -4645,6 +4953,7 @@ var Resolver = class {
             fieldValue.map(async (item) => {
               if (typeof item === "string") {
                 throw new Error(
+                  //@ts-ignore
                   `Expected object for template value for field ${field.name}`
                 );
               }
@@ -4653,16 +4962,19 @@ var Resolver = class {
               });
               const [templateName] = Object.entries(item)[0];
               const template = templates.find(
+                //@ts-ignore
                 (template2) => template2.name === templateName
               );
               if (!template) {
                 throw new Error(`Expected to find template ${templateName}`);
               }
               return {
+                // @ts-ignore FIXME Argument of type 'unknown' is not assignable to parameter of type '{ [fieldName: string]: string | { [key: string]: unknown; } | (string | { [key: string]: unknown; })[]; }'
                 ...await this.buildFieldMutations(
                   item[template.name],
                   template
                 ),
+                //@ts-ignore
                 _template: template.name
               };
             })
@@ -4670,6 +4982,7 @@ var Resolver = class {
         } else {
           if (typeof fieldValue === "string") {
             throw new Error(
+              //@ts-ignore
               `Expected object for template value for field ${field.name}`
             );
           }
@@ -4678,16 +4991,19 @@ var Resolver = class {
           });
           const [templateName] = Object.entries(fieldValue)[0];
           const template = templates.find(
+            //@ts-ignore
             (template2) => template2.name === templateName
           );
           if (!template) {
             throw new Error(`Expected to find template ${templateName}`);
           }
           return {
+            // @ts-ignore FIXME Argument of type 'unknown' is not assignable to parameter of type '{ [fieldName: string]: string | { [key: string]: unknown; } | (string | { [key: string]: unknown; })[]; }'
             ...await this.buildFieldMutations(
               fieldValue[template.name],
               template
             ),
+            //@ts-ignore
             _template: template.name
           };
         }
@@ -4727,6 +5043,7 @@ var Resolver = class {
         return this.getDocument(realPath);
       }
       const params = await this.buildObjectMutations(
+        // @ts-ignore
         args.params[collection.name],
         collection
       );
@@ -4772,6 +5089,7 @@ var Resolver = class {
                 const values = {
                   ...oldDoc,
                   ...await this.buildFieldMutations(
+                    // @ts-ignore FIXME: failing on unknown, which we don't need to know because it's recursive
                     templateParams,
                     template,
                     doc?._rawData
@@ -4785,13 +5103,22 @@ var Resolver = class {
         return this.getDocument(realPath);
       }
       const params = await this.buildObjectMutations(
+        //@ts-ignore
         isCollectionSpecific ? args.params : args.params[collection.name],
         collection,
         doc?._rawData
       );
-      await this.database.put(realPath, { ...oldDoc, ...params }, collection.name);
+      await this.database.put(
+        realPath,
+        { ...oldDoc, ...params },
+        collection.name
+      );
       return this.getDocument(realPath);
     };
+    /**
+     * Returns top-level fields which are not defined in the collection, so their
+     * values are not eliminated from Tina when new values are saved
+     */
     this.resolveLegacyValues = (oldDoc, collection) => {
       const legacyValues = {};
       Object.entries(oldDoc).forEach(([key, value]) => {
@@ -4896,6 +5223,40 @@ var Resolver = class {
         if (isDeletion) {
           const doc = await this.getDocument(realPath);
           await this.deleteDocument(realPath);
+          if (await this.hasReferences(realPath, collection)) {
+            const collRefs = await this.findReferences(realPath, collection);
+            for (const [collection2, docsWithRefs] of Object.entries(collRefs)) {
+              for (const [pathToDocWithRef, referencePaths] of Object.entries(
+                docsWithRefs
+              )) {
+                let refDoc = await this.getRaw(pathToDocWithRef);
+                let hasUpdate = false;
+                for (const path7 of referencePaths) {
+                  const { object: object2, updated } = updateObjectWithJsonPath(
+                    refDoc,
+                    path7,
+                    realPath,
+                    null
+                  );
+                  refDoc = object2;
+                  hasUpdate = updated || hasUpdate;
+                }
+                if (hasUpdate) {
+                  const collectionWithRef = this.tinaSchema.getCollectionByFullPath(pathToDocWithRef);
+                  if (!collectionWithRef) {
+                    throw new Error(
+                      `Unable to find collection for ${pathToDocWithRef}`
+                    );
+                  }
+                  await this.database.put(
+                    pathToDocWithRef,
+                    refDoc,
+                    collectionWithRef.name
+                  );
+                }
+              }
+            }
+          }
           return doc;
         }
         if (isUpdateName) {
@@ -4912,12 +5273,49 @@ var Resolver = class {
             collection?.path,
             args.params.relativePath
           );
+          if (newRealPath === realPath) {
+            return doc;
+          }
           await this.database.put(newRealPath, doc._rawData, collection.name);
           await this.deleteDocument(realPath);
+          const collRefs = await this.findReferences(realPath, collection);
+          for (const [collection2, docsWithRefs] of Object.entries(collRefs)) {
+            for (const [pathToDocWithRef, referencePaths] of Object.entries(
+              docsWithRefs
+            )) {
+              let docWithRef = await this.getRaw(pathToDocWithRef);
+              let hasUpdate = false;
+              for (const path7 of referencePaths) {
+                const { object: object2, updated } = updateObjectWithJsonPath(
+                  docWithRef,
+                  path7,
+                  realPath,
+                  newRealPath
+                );
+                docWithRef = object2;
+                hasUpdate = updated || hasUpdate;
+              }
+              if (hasUpdate) {
+                const collectionWithRef = this.tinaSchema.getCollectionByFullPath(pathToDocWithRef);
+                if (!collectionWithRef) {
+                  throw new Error(
+                    `Unable to find collection for ${pathToDocWithRef}`
+                  );
+                }
+                await this.database.put(
+                  pathToDocWithRef,
+                  docWithRef,
+                  collectionWithRef.name
+                );
+              }
+            }
+          }
           return this.getDocument(newRealPath);
         }
         if (alreadyExists === false) {
-          throw new Error(`Unable to update document, ${realPath} does not exist`);
+          throw new Error(
+            `Unable to update document, ${realPath} does not exist`
+          );
         }
         return this.updateResolveDocument({
           collection,
@@ -4927,7 +5325,10 @@ var Resolver = class {
           isCollectionSpecific
         });
       } else {
-        return this.getDocument(realPath);
+        return this.getDocument(realPath, {
+          collection,
+          checkReferences: true
+        });
       }
     };
     this.resolveCollectionConnections = async ({ ids }) => {
@@ -4964,6 +5365,7 @@ var Resolver = class {
           },
           collection: referencedCollection,
           hydrator: (path7) => path7
+          // just return the path
         }
       );
       const { edges } = resolvedCollectionConnection;
@@ -5031,6 +5433,82 @@ var Resolver = class {
         }
       };
     };
+    /**
+     * Checks if a document has references to it
+     * @param id  The id of the document to check for references
+     * @param c The collection to check for references
+     * @returns true if the document has references, false otherwise
+     */
+    this.hasReferences = async (id, c) => {
+      let count = 0;
+      await this.database.query(
+        {
+          collection: c.name,
+          filterChain: makeFilterChain({
+            conditions: [
+              {
+                filterPath: REFS_REFERENCE_FIELD,
+                filterExpression: {
+                  _type: "string",
+                  _list: false,
+                  eq: id
+                }
+              }
+            ]
+          }),
+          sort: REFS_COLLECTIONS_SORT_KEY
+        },
+        (refId) => {
+          count++;
+          return refId;
+        }
+      );
+      if (count) {
+        return true;
+      }
+      return false;
+    };
+    /**
+     * Finds references to a document
+     * @param id the id of the document to find references to
+     * @param c the collection to find references in
+     * @returns a map of references to the document
+     */
+    this.findReferences = async (id, c) => {
+      const references = {};
+      await this.database.query(
+        {
+          collection: c.name,
+          filterChain: makeFilterChain({
+            conditions: [
+              {
+                filterPath: REFS_REFERENCE_FIELD,
+                filterExpression: {
+                  _type: "string",
+                  _list: false,
+                  eq: id
+                }
+              }
+            ]
+          }),
+          sort: REFS_COLLECTIONS_SORT_KEY
+        },
+        (refId, rawItem) => {
+          if (!references[c.name]) {
+            references[c.name] = {};
+          }
+          if (!references[c.name][refId]) {
+            references[c.name][refId] = [];
+          }
+          const referencePath = rawItem?.[REFS_PATH_FIELD];
+          if (referencePath) {
+            references[c.name][refId].push(referencePath);
+          }
+          return refId;
+        }
+      );
+      return references;
+    };
     this.buildFieldMutations = async (fieldParams, template, existingData) => {
       const accum = {};
       for (const passwordField of template.fields.filter(
@@ -5117,6 +5595,27 @@ var Resolver = class {
       }
       return accum;
     };
+    /**
+     * A mutation looks nearly identical between updateDocument:
+     * ```graphql
+     * updateDocument(collection: $collection,relativePath: $path, params: {
+     *   post: {
+     *     title: "Hello, World"
+     *   }
+     * })`
+     * ```
+     * and `updatePostDocument`:
+     * ```graphql
+     * updatePostDocument(relativePath: $path, params: {
+     *   title: "Hello, World"
+     * })
+     * ```
+     * The problem here is that we don't know whether the payload came from `updateDocument`
+     * or `updatePostDocument` (we could, but for now it's easier not to pipe those details through),
+     * But we do know that when given a `args.collection` value, we can assume that
+     * this was a `updateDocument` request, and thus - should grab the data
+     * from the corresponding field name in the key
+     */
     this.buildParams = (args) => {
       try {
         assertShape(
@@ -5216,7 +5715,10 @@ var resolve = async ({
     const graphQLSchema = buildASTSchema(graphQLSchemaAst);
     const tinaConfig = await database.getTinaSchema();
     const tinaSchema = await createSchema({
+      // TODO: please update all the types to import from @tinacms/schema-tools
+      // @ts-ignore
       schema: tinaConfig,
+      // @ts-ignore
       flags: tinaConfig?.meta?.flags
     });
     const resolver = createResolver({
@@ -5233,8 +5735,7 @@ var resolve = async ({
         database
       },
       typeResolver: async (source, _args, info) => {
-        if (source.__typename)
-          return source.__typename;
+        if (source.__typename) return source.__typename;
         const namedType = getNamedType(info.returnType).toString();
         const lookup = await database.getLookup(namedType);
         if (lookup.resolveType === "unionData") {
@@ -5383,11 +5884,13 @@ var resolve = async ({
             set(
               params,
               userField.path.slice(1),
+              // remove _rawData from users path
               users.map((u) => {
                 if (user[idFieldName] === u[idFieldName]) {
                   return user;
                 }
                 return {
+                  // don't overwrite other users' passwords
                   ...u,
                   [passwordFieldName]: {
                     ...u[passwordFieldName],
@@ -5410,6 +5913,9 @@ var resolve = async ({
           }
           const isCreation = lookup[info.fieldName] === "create";
           switch (lookup.resolveType) {
+            /**
+             * `node(id: $id)`
+             */
             case "nodeDocument":
               assertShape(
                 args,
@@ -5441,6 +5947,7 @@ var resolve = async ({
                   collection: args.collection,
                   isMutation,
                   isCreation,
+                  // Right now this is the only case for deletion
                   isDeletion: info.fieldName === "deleteDocument",
                   isFolderCreation: info.fieldName === "createFolder",
                   isUpdateName: Boolean(args?.params?.relativePath),
@@ -5450,6 +5957,9 @@ var resolve = async ({
                 return result;
               }
               return value;
+            /**
+             * eg `getMovieDocument.data.actors`
+             */
             case "multiCollectionDocumentList":
               if (Array.isArray(value)) {
                 return {
@@ -5461,7 +5971,15 @@ var resolve = async ({
               }
               if (info.fieldName === "documents" && value?.collection && value?.hasDocuments) {
                 let filter = args.filter;
-                if (typeof args?.filter !== "undefined" && args?.filter !== null && typeof value?.collection?.name === "string" && Object.keys(args.filter).includes(value?.collection?.name) && typeof args.filter[value?.collection?.name] !== "undefined") {
+                if (
+                  // 1. Make sure that the filter exists
+                  typeof args?.filter !== "undefined" && args?.filter !== null && // 2. Make sure that the collection name exists
+                  // @ts-ignore
+                  typeof value?.collection?.name === "string" && // 3. Make sure that the collection name is in the filter and is not undefined
+                  // @ts-ignore
+                  Object.keys(args.filter).includes(value?.collection?.name) && // @ts-ignore
+                  typeof args.filter[value?.collection?.name] !== "undefined"
+                ) {
                   filter = args.filter[value.collection.name];
                 }
                 return resolver.resolveCollectionConnection({
@@ -5469,12 +5987,20 @@ var resolve = async ({
                     ...args,
                     filter
                   },
+                  // @ts-ignore
                   collection: value.collection
                 });
               }
               throw new Error(
                 `Expected an array for result of ${info.fieldName} at ${info.path}`
               );
+            /**
+             * Collections-specific getter
+             * eg. `getPostDocument`/`createPostDocument`/`updatePostDocument`
+             *
+             * if coming from a query result
+             * the field will be `node`
+             */
             case "collectionDocument": {
               if (value) {
                 return value;
@@ -5489,11 +6015,32 @@ var resolve = async ({
               });
               return result;
             }
+            /**
+             * Collections-specific list getter
+             * eg. `getPageList`
+             */
             case "collectionDocumentList":
               return resolver.resolveCollectionConnection({
                 args,
                 collection: tinaSchema.getCollection(lookup.collection)
               });
+            /**
+             * A polymorphic data set, it can be from a document's data
+             * of any nested object which can be one of many shapes
+             *
+             * ```graphql
+             * getPostDocument(relativePath: $relativePath) {
+             *   data {...} <- this part
+             * }
+             * ```
+             * ```graphql
+             * getBlockDocument(relativePath: $relativePath) {
+             *   data {
+             *     blocks {...} <- or this part
+             *   }
+             * }
+             * ```
+             */
             case "unionData":
               if (!value) {
                 if (args.relativePath) {
@@ -5558,8 +6105,7 @@ var TinaLevelClient = class extends ManyLevelGuest {
     this.port = port || 9e3;
   }
   openConnection() {
-    if (this._connected)
-      return;
+    if (this._connected) return;
     const socket = connect(this.port);
     pipeline(socket, this.createRpcStream(), socket, () => {
       this._connected = false;
@@ -5569,7 +6115,7 @@ var TinaLevelClient = class extends ManyLevelGuest {
 };
 
 // src/database/index.ts
-import path4 from "path";
+import path4 from "node:path";
 import { GraphQLError as GraphQLError5 } from "graphql";
 import micromatch2 from "micromatch";
 import sha2 from "js-sha1";
@@ -5704,6 +6250,7 @@ var Database = class {
       );
       const indexDefinitions = await this.getIndexDefinitions(this.contentLevel);
       const collectionIndexDefinitions = indexDefinitions?.[collection.name];
+      const collectionReferences = (await this.getCollectionReferences())?.[collection.name];
       const normalizedPath = normalizePath(filepath);
       if (!collection?.isDetached) {
         if (this.bridge) {
@@ -5732,6 +6279,14 @@ var Database = class {
       let delOps = [];
       if (!isGitKeep(normalizedPath, collection)) {
         putOps = [
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection?.name,
+            collectionReferences,
+            dataFields,
+            "put",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection?.name,
@@ -5740,6 +6295,7 @@ var Database = class {
             "put",
             level
           ),
+          // folder indices
           ...makeIndexOpsForDocument(
             normalizedPath,
             `${collection?.name}_${folderKey}`,
@@ -5754,6 +6310,14 @@ var Database = class {
           SUBLEVEL_OPTIONS
         ).get(normalizedPath);
         delOps = existingItem ? [
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection?.name,
+            collectionReferences,
+            existingItem,
+            "del",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection?.name,
@@ -5762,6 +6326,7 @@ var Database = class {
             "del",
             level
           ),
+          // folder indices
           ...makeIndexOpsForDocument(
             normalizedPath,
             `${collection?.name}_${folderKey}`,
@@ -5800,6 +6365,7 @@ var Database = class {
             );
             collectionIndexDefinitions = indexDefinitions?.[collectionName];
           }
+          const collectionReferences = (await this.getCollectionReferences())?.[collectionName];
           const normalizedPath = normalizePath(filepath);
           const dataFields = await this.formatBodyOnPayload(filepath, data);
           const collection = await this.collectionForPath(filepath);
@@ -5847,6 +6413,14 @@ var Database = class {
           let delOps = [];
           if (!isGitKeep(normalizedPath, collection)) {
             putOps = [
+              ...makeRefOpsForDocument(
+                normalizedPath,
+                collectionName,
+                collectionReferences,
+                dataFields,
+                "put",
+                level
+              ),
               ...makeIndexOpsForDocument(
                 normalizedPath,
                 collectionName,
@@ -5855,6 +6429,7 @@ var Database = class {
                 "put",
                 level
               ),
+              // folder indices
               ...makeIndexOpsForDocument(
                 normalizedPath,
                 `${collection?.name}_${folderKey}`,
@@ -5869,6 +6444,14 @@ var Database = class {
               SUBLEVEL_OPTIONS
             ).get(normalizedPath);
             delOps = existingItem ? [
+              ...makeRefOpsForDocument(
+                normalizedPath,
+                collectionName,
+                collectionReferences,
+                existingItem,
+                "del",
+                level
+              ),
               ...makeIndexOpsForDocument(
                 normalizedPath,
                 collectionName,
@@ -5877,6 +6460,7 @@ var Database = class {
                 "del",
                 level
               ),
+              // folder indices
               ...makeIndexOpsForDocument(
                 normalizedPath,
                 `${collection?.name}_${folderKey}`,
@@ -5954,6 +6538,7 @@ var Database = class {
         aliasedData,
         extension,
         writeTemplateKey,
+        //templateInfo.type === 'union',
         {
           frontmatterFormat: collection?.frontmatterFormat,
           frontmatterDelimiters: collection?.frontmatterDelimiters
@@ -5992,6 +6577,7 @@ var Database = class {
         SUBLEVEL_OPTIONS
       ).get(graphqlPath);
     };
+    //TODO - is there a reason why the database fetches some config with "bridge.get", and some with "store.get"?
     this.getGraphQLSchemaFromBridge = async () => {
       if (!this.bridge) {
         throw new Error(`No bridge configured`);
@@ -6028,6 +6614,22 @@ var Database = class {
       this.tinaSchema = await createSchema({ schema });
       return this.tinaSchema;
     };
+    this.getCollectionReferences = async (level) => {
+      if (this.collectionReferences) {
+        return this.collectionReferences;
+      }
+      const result = {};
+      const schema = await this.getSchema(level || this.contentLevel);
+      const collections = schema.getCollections();
+      for (const collection of collections) {
+        const collectionReferences = this.tinaSchema.findReferencesFromCollection(
+          collection.name
+        );
+        result[collection.name] = collectionReferences;
+      }
+      this.collectionReferences = result;
+      return result;
+    };
     this.getIndexDefinitions = async (level) => {
       if (!this.collectionIndexDefinitions) {
         await new Promise(async (resolve2, reject) => {
@@ -6037,10 +6639,53 @@ var Database = class {
             const collections = schema.getCollections();
             for (const collection of collections) {
               const indexDefinitions = {
-                [DEFAULT_COLLECTION_SORT_KEY]: { fields: [] }
+                [DEFAULT_COLLECTION_SORT_KEY]: { fields: [] },
+                // provide a default sort key which is the file sort
+                // pseudo-index for the collection's references
+                [REFS_COLLECTIONS_SORT_KEY]: {
+                  fields: [
+                    {
+                      name: REFS_REFERENCE_FIELD,
+                      type: "string",
+                      list: false
+                    },
+                    {
+                      name: REFS_PATH_FIELD,
+                      type: "string",
+                      list: false
+                    }
+                  ]
+                }
               };
-              if (collection.fields) {
-                for (const field of collection.fields) {
+              let fields = [];
+              if (collection.templates) {
+                const templateFieldMap = {};
+                const conflictedFields = /* @__PURE__ */ new Set();
+                for (const template of collection.templates) {
+                  for (const field of template.fields) {
+                    if (!templateFieldMap[field.name]) {
+                      templateFieldMap[field.name] = field;
+                    } else {
+                      if (templateFieldMap[field.name].type !== field.type) {
+                        console.warn(
+                          `Field ${field.name} has conflicting types in templates - skipping index`
+                        );
+                        conflictedFields.add(field.name);
+                      }
+                    }
+                  }
+                }
+                for (const conflictedField in conflictedFields) {
+                  delete templateFieldMap[conflictedField];
+                }
+                for (const field of Object.values(templateFieldMap)) {
+                  fields.push(field);
+                }
+              } else if (collection.fields) {
+                fields = collection.fields;
+              }
+              if (fields) {
+                for (const field of fields) {
                   if (field.indexed !== void 0 && field.indexed === false || field.type === "object") {
                     continue;
                   }
@@ -6188,29 +6833,36 @@ var Database = class {
         }
         startKey = startKey || key || "";
         endKey = key || "";
-        edges = [...edges, { cursor: key, path: filepath }];
+        edges = [...edges, { cursor: key, path: filepath, value: itemRecord }];
       }
       return {
-        edges: await sequential(edges, async (edge) => {
-          try {
-            const node = await hydrator(edge.path);
-            return {
-              node,
-              cursor: btoa(edge.cursor)
-            };
-          } catch (error) {
-            console.log(error);
-            if (error instanceof Error && (!edge.path.includes(".tina/__generated__/_graphql.json") || !edge.path.includes("tina/__generated__/_graphql.json"))) {
-              throw new TinaQueryError({
-                originalError: error,
-                file: edge.path,
-                collection: collection.name,
-                stack: error.stack
-              });
+        edges: await sequential(
+          edges,
+          async ({
+            cursor,
+            path: path7,
+            value
+          }) => {
+            try {
+              const node = await hydrator(path7, value);
+              return {
+                node,
+                cursor: btoa(cursor)
+              };
+            } catch (error) {
+              console.log(error);
+              if (error instanceof Error && (!path7.includes(".tina/__generated__/_graphql.json") || !path7.includes("tina/__generated__/_graphql.json"))) {
+                throw new TinaQueryError({
+                  originalError: error,
+                  file: path7,
+                  collection: collection.name,
+                  stack: error.stack
+                });
+              }
+              throw error;
             }
-            throw error;
           }
-        }),
+        ),
         pageInfo: {
           hasPreviousPage,
           hasNextPage,
@@ -6356,17 +7008,18 @@ var Database = class {
         throw new Error(`No collection found for path: ${filepath}`);
       }
       const indexDefinitions = await this.getIndexDefinitions(this.contentLevel);
+      const collectionReferences = (await this.getCollectionReferences())?.[collection.name];
       const collectionIndexDefinitions = indexDefinitions?.[collection.name];
       let level = this.contentLevel;
       if (collection?.isDetached) {
         level = this.appLevel.sublevel(collection?.name, SUBLEVEL_OPTIONS);
       }
-      const itemKey = normalizePath(filepath);
+      const normalizedPath = normalizePath(filepath);
       const rootSublevel = level.sublevel(
         CONTENT_ROOT_PREFIX,
         SUBLEVEL_OPTIONS
       );
-      const item = await rootSublevel.get(itemKey);
+      const item = await rootSublevel.get(normalizedPath);
       if (item) {
         const folderTreeBuilder = new FolderTreeBuilder();
         const folderKey = folderTreeBuilder.update(
@@ -6374,16 +7027,25 @@ var Database = class {
           collection.path || ""
         );
         await this.contentLevel.batch([
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection.name,
+            collectionReferences,
+            item,
+            "del",
+            level
+          ),
           ...makeIndexOpsForDocument(
-            filepath,
+            normalizedPath,
             collection.name,
             collectionIndexDefinitions,
             item,
             "del",
             level
           ),
+          // folder indices
           ...makeIndexOpsForDocument(
-            filepath,
+            normalizedPath,
             `${collection.name}_${folderKey}`,
             collectionIndexDefinitions,
             item,
@@ -6392,17 +7054,17 @@ var Database = class {
           ),
           {
             type: "del",
-            key: itemKey,
+            key: normalizedPath,
             sublevel: rootSublevel
           }
         ]);
       }
       if (!collection?.isDetached) {
         if (this.bridge) {
-          await this.bridge.delete(normalizePath(filepath));
+          await this.bridge.delete(normalizedPath);
         }
         try {
-          await this.onDelete(normalizePath(filepath));
+          await this.onDelete(normalizedPath);
         } catch (e) {
           throw new GraphQLError5(
             `Error running onDelete hook for ${filepath}: ${e}`,
@@ -6450,7 +7112,13 @@ var Database = class {
               );
             }
           } else {
-            await _indexContent(this, level, contentPaths, enqueueOps, collection);
+            await _indexContent(
+              this,
+              level,
+              contentPaths,
+              enqueueOps,
+              collection
+            );
           }
         }
       );
@@ -6536,6 +7204,9 @@ var Database = class {
       info: templateInfo
     };
   }
+  /**
+   * Clears the internal cache of the tinaSchema and the lookup file. This allows the state to be reset
+   */
   clearCache() {
     this.tinaSchema = null;
     this._lookup = null;
@@ -6597,6 +7268,7 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
     }
     collectionPath = collection.path;
   }
+  const collectionReferences = (await database.getCollectionReferences())?.[collection?.name];
   const tinaSchema = await database.getSchema();
   let templateInfo = null;
   if (collection) {
@@ -6618,12 +7290,59 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
         await hashPasswordValues(aliasedData, passwordFields);
       }
       const normalizedPath = normalizePath(filepath);
+      const rootSublevel = level.sublevel(
+        CONTENT_ROOT_PREFIX,
+        SUBLEVEL_OPTIONS
+      );
       const folderKey = folderTreeBuilder.update(
         normalizedPath,
         collectionPath || ""
       );
+      const item = await rootSublevel.get(normalizedPath);
+      if (item) {
+        await database.contentLevel.batch([
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection?.name,
+            collectionReferences,
+            item,
+            "del",
+            level
+          ),
+          ...makeIndexOpsForDocument(
+            normalizedPath,
+            collection.name,
+            collectionIndexDefinitions,
+            item,
+            "del",
+            level
+          ),
+          // folder indices
+          ...makeIndexOpsForDocument(
+            normalizedPath,
+            `${collection.name}_${folderKey}`,
+            collectionIndexDefinitions,
+            item,
+            "del",
+            level
+          ),
+          {
+            type: "del",
+            key: normalizedPath,
+            sublevel: rootSublevel
+          }
+        ]);
+      }
       if (!isGitKeep(filepath, collection)) {
         await enqueueOps([
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection?.name,
+            collectionReferences,
+            aliasedData,
+            "put",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection?.name,
@@ -6632,6 +7351,7 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
             "put",
             level
           ),
+          // folder indexes
           ...makeIndexOpsForDocument(
             normalizedPath,
             `${collection?.name}_${folderKey}`,
@@ -6686,6 +7406,7 @@ var _deleteIndexContent = async (database, documentPaths, enqueueOps, collection
       throw new Error(`No indexDefinitions for collection ${collection.name}`);
     }
   }
+  const collectionReferences = (await database.getCollectionReferences())?.[collection?.name];
   const tinaSchema = await database.getSchema();
   let templateInfo = null;
   if (collection) {
@@ -6709,6 +7430,14 @@ var _deleteIndexContent = async (database, documentPaths, enqueueOps, collection
         item
       ) : item;
       await enqueueOps([
+        ...makeRefOpsForDocument(
+          itemKey,
+          collection?.name,
+          collectionReferences,
+          aliasedData,
+          "del",
+          database.contentLevel
+        ),
         ...makeIndexOpsForDocument(
           itemKey,
           collection.name,
@@ -6717,6 +7446,7 @@ var _deleteIndexContent = async (database, documentPaths, enqueueOps, collection
           "del",
           database.contentLevel
         ),
+        // folder indexes
         ...makeIndexOpsForDocument(
           itemKey,
           `${collection?.name}_${folderKey}`,
@@ -6932,17 +7662,26 @@ var IsomorphicBridge = class {
   getAuthor() {
     return {
       ...this.author,
-      timestamp: Math.round(new Date().getTime() / 1e3),
+      timestamp: Math.round((/* @__PURE__ */ new Date()).getTime() / 1e3),
       timezoneOffset: 0
     };
   }
   getCommitter() {
     return {
       ...this.committer,
-      timestamp: Math.round(new Date().getTime() / 1e3),
+      timestamp: Math.round((/* @__PURE__ */ new Date()).getTime() / 1e3),
       timezoneOffset: 0
     };
   }
+  /**
+   * Recursively populate paths matching `pattern` for the given `entry`
+   *
+   * @param pattern - pattern to filter paths by
+   * @param entry - TreeEntry to start building list from
+   * @param path - base path
+   * @param results
+   * @private
+   */
   async listEntries({
     pattern,
     entry,
@@ -6975,6 +7714,15 @@ var IsomorphicBridge = class {
       });
     }
   }
+  /**
+   * For the specified path, returns an object with an array containing the parts of the path (pathParts)
+   * and an array containing the WalkerEntry objects for the path parts (pathEntries). Any null elements in the
+   * pathEntries are placeholders for non-existent entries.
+   *
+   * @param path - path being resolved
+   * @param ref - ref to resolve path entries for
+   * @private
+   */
   async resolvePathEntries(path7, ref) {
     let pathParts = path7.split("/");
     const result = await git2.walk({
@@ -7005,6 +7753,17 @@ var IsomorphicBridge = class {
     }
     return { pathParts, pathEntries };
   }
+  /**
+   * Updates tree entry and associated parent tree entries
+   *
+   * @param existingOid - the existing OID
+   * @param updatedOid - the updated OID
+   * @param path - the path of the entry being updated
+   * @param type - the type of the entry being updated (blob or tree)
+   * @param pathEntries - parent path entries
+   * @param pathParts - parent path parts
+   * @private
+   */
   async updateTreeHierarchy(existingOid, updatedOid, path7, type, pathEntries, pathParts) {
     const lastIdx = pathEntries.length - 1;
     const parentEntry = pathEntries[lastIdx];
@@ -7060,6 +7819,13 @@ var IsomorphicBridge = class {
       );
     }
   }
+  /**
+   * Creates a commit for the specified tree and updates the specified ref to point to the commit
+   *
+   * @param treeSha - sha of the new tree
+   * @param ref - the ref that should be updated
+   * @private
+   */
   async commitTree(treeSha, ref) {
     const commitSha = await git2.writeCommit({
       ...this.isomorphicConfig,
@@ -7072,6 +7838,7 @@ var IsomorphicBridge = class {
           })
         ],
         message: this.commitMessage,
+        // TODO these should be configurable
         author: this.getAuthor(),
         committer: this.getCommitter()
       }
@@ -7309,5 +8076,5 @@ export {
   transformDocument,
   transformDocumentIntoPayload
 };
-//! Replaces _.flattenDeep()
 //! Replaces _.get()
+//! Replaces _.flattenDeep()