@tinacms/graphql 0.0.0-c852462-20250131014229 → 0.0.0-cacbd0e-20250306051805

package/dist/index.mjs

@@ -3019,7 +3019,7 @@ var validateField = async (field) => {
 // package.json
 var package_default = {
   name: "@tinacms/graphql",
-  version: "1.5.11",
+  version: "1.5.14",
   main: "dist/index.js",
   module: "dist/index.mjs",
   typings: "dist/index.d.ts",
@@ -3055,12 +3055,12 @@ 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": "10.1.0",
@@ -3070,7 +3070,7 @@ var package_default = {
     "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"
   },
@@ -3094,17 +3094,17 @@ var package_default = {
     "@types/lru-cache": "^5.1.1",
     "@types/mdast": "^3.0.15",
     "@types/micromatch": "^4.0.9",
-    "@types/node": "^22.9.0",
+    "@types/node": "^22.13.1",
     "@types/normalize-path": "^3.0.2",
     "@types/ws": "^7.4.7",
     "@types/yup": "^0.29.14",
     "jest-file-snapshot": "^0.5.0",
     "memory-level": "^1.0.0",
     nodemon: "3.1.4",
-    typescript: "^5.6.3",
-    vite: "^4.3.9",
-    vitest: "^0.32.2",
-    zod: "^3.23.8"
+    typescript: "^5.7.3",
+    vite: "^4.5.9",
+    vitest: "^0.32.4",
+    zod: "^3.24.2"
   }
 };
 
@@ -3260,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)
@@ -3575,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) => {
@@ -3960,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) {
@@ -4533,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)) {
@@ -4557,16 +4615,7 @@ var stringEscaper = makeStringEscaper(
 var createResolver = (args) => {
   return new Resolver(args);
 };
-var resolveFieldData = async (args) => {
-  const {
-    field: { namespace, ...field },
-    rawData,
-    accumulator,
-    tinaSchema,
-    config,
-    isAudit,
-    context
-  } = args;
+var resolveFieldData = async ({ namespace, ...field }, rawData, accumulator, tinaSchema, config, isAudit) => {
   if (!rawData) {
     return void 0;
   }
@@ -4606,11 +4655,9 @@ var resolveFieldData = async (args) => {
       break;
     case "rich-text":
       const tree = parseMDX(
-        // @ts-ignore value is unknown
         value,
         field,
-        (value2) => resolveMediaRelativeToCloud(value2, config, tinaSchema.schema),
-        context
+        (value2) => resolveMediaRelativeToCloud(value2, config, tinaSchema.schema)
       );
       if (tree?.children[0]?.type === "invalid_markdown") {
         if (isAudit) {
@@ -4641,15 +4688,14 @@ var resolveFieldData = async (args) => {
           });
           const payload = {};
           await sequential(template.fields, async (field2) => {
-            await resolveFieldData({
-              field: field2,
-              rawData: item,
-              accumulator: payload,
+            await resolveFieldData(
+              field2,
+              item,
+              payload,
               tinaSchema,
               config,
-              isAudit,
-              context
-            });
+              isAudit
+            );
           });
           const isUnion = !!field.templates;
           return isUnion ? {
@@ -4670,15 +4716,14 @@ var resolveFieldData = async (args) => {
         });
         const payload = {};
         await sequential(template.fields, async (field2) => {
-          await resolveFieldData({
-            field: field2,
-            rawData: value,
-            accumulator: payload,
+          await resolveFieldData(
+            field2,
+            value,
+            payload,
             tinaSchema,
             config,
-            isAudit,
-            context
-          });
+            isAudit
+          );
         });
         const isUnion = !!field.templates;
         accumulator[field.name] = isUnion ? {
@@ -4692,8 +4737,7 @@ var resolveFieldData = async (args) => {
   }
   return accumulator;
 };
-var transformDocumentIntoPayload = async (args) => {
-  const { fullPath, rawData, tinaSchema, config, isAudit, context } = args;
+var transformDocumentIntoPayload = async (fullPath, rawData, tinaSchema, config, isAudit, hasReferences) => {
   const collection = tinaSchema.getCollection(rawData._collection);
   try {
     const template = tinaSchema.getTemplateForData({
@@ -4713,15 +4757,14 @@ var transformDocumentIntoPayload = async (args) => {
     };
     try {
       await sequential(template.fields, async (field) => {
-        return resolveFieldData({
+        return resolveFieldData(
           field,
           rawData,
-          accumulator: data,
+          data,
           tinaSchema,
           config,
-          isAudit,
-          context
-        });
+          isAudit
+        );
       });
     } catch (e) {
       throw new TinaParseDocumentError({
@@ -4748,7 +4791,7 @@ var transformDocumentIntoPayload = async (args) => {
         basename,
         filename,
         extension,
-        hasReferences: args.hasReferences,
+        hasReferences,
         path: fullPath,
         relativePath,
         breadcrumbs,
@@ -4768,29 +4811,33 @@ var transformDocumentIntoPayload = async (args) => {
     throw e;
   }
 };
-var updateObjectWithJsonPath = (obj, path7, newValue) => {
+var updateObjectWithJsonPath = (obj, path7, oldValue, newValue) => {
+  let updated = false;
   if (!path7.includes(".") && !path7.includes("[")) {
-    if (path7 in obj) {
+    if (path7 in obj && obj[path7] === oldValue) {
       obj[path7] = newValue;
+      updated = true;
     }
-    return obj;
+    return { object: obj, updated };
   }
-  const parentPath = path7.replace(/\.[^.]+$/, "");
-  const keyToUpdate = path7.match(/[^.]+$/)[0];
+  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) {
-        parent[keyToUpdate] = newValue;
+        if (parent[keyToUpdate] === oldValue) {
+          parent[keyToUpdate] = newValue;
+          updated = true;
+        }
       }
     });
   }
-  return obj;
+  return { object: obj, updated };
 };
 var Resolver = class {
   constructor(init) {
     this.init = init;
-    this.context = {};
     this.resolveCollection = async (args, collectionName, hasDocuments) => {
       const collection = this.tinaSchema.getCollection(collectionName);
       const extraFields = {};
@@ -4803,7 +4850,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);
     };
@@ -4821,37 +4870,37 @@ var Resolver = class {
           path: rawData["__folderPath"]
         };
       } else {
-        this.context = { ...rawData };
-        return transformDocumentIntoPayload({
+        return transformDocumentIntoPayload(
           fullPath,
           rawData,
-          tinaSchema: this.tinaSchema,
-          config: this.config,
-          isAudit: this.isAudit,
-          context: this.context
-        });
+          this.tinaSchema,
+          this.config,
+          this.isAudit
+        );
       }
     };
     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);
-      this.context = { ...rawData };
       const hasReferences = opts?.checkReferences ? await this.hasReferences(fullPath, opts.collection) : void 0;
-      return transformDocumentIntoPayload({
+      return transformDocumentIntoPayload(
         fullPath,
         rawData,
-        tinaSchema: this.tinaSchema,
-        config: this.config,
-        isAudit: this.isAudit,
-        context: this.context,
+        this.tinaSchema,
+        this.config,
+        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);
     };
@@ -5006,31 +5055,34 @@ var Resolver = class {
     }) => {
       const doc = await this.getDocument(realPath);
       const oldDoc = this.resolveLegacyValues(doc?._rawData || {}, collection);
-      let values;
       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 mutationValues = await this.buildFieldMutations(
-                params,
+            if (params2) {
+              const values = await this.buildFieldMutations(
+                params2,
                 templateInfo.template,
                 doc?._rawData
               );
-              values = { ...oldDoc, ...mutationValues };
+              await this.database.put(
+                realPath,
+                { ...oldDoc, ...values },
+                collection.name
+              );
             }
             break;
-          case "union": {
+          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 object for template params, but got string`
                   );
                 }
-                values = {
+                const values = {
                   ...oldDoc,
                   ...await this.buildFieldMutations(
                     // @ts-ignore FIXME: failing on unknown, which we don't need to know because it's recursive
@@ -5040,23 +5092,21 @@ var Resolver = class {
                   ),
                   _template: lastItem(template.namespace)
                 };
+                await this.database.put(realPath, values, collection.name);
               }
             });
-          }
         }
-      } else {
-        const params = await this.buildObjectMutations(
-          //@ts-expect-error FIXME: Argument of type 'unknown' is not assignable to parameter of type 'FieldParams'
-          isCollectionSpecific ? args.params : args.params[collection.name],
-          collection,
-          doc?._rawData
-        );
-        values = { ...oldDoc, ...params };
+        return this.getDocument(realPath);
       }
-      const _tinaEmbeds = this.context?._tinaEmbeds ? { _tinaEmbeds: this.context._tinaEmbeds } : {};
+      const params = await this.buildObjectMutations(
+        //@ts-ignore
+        isCollectionSpecific ? args.params : args.params[collection.name],
+        collection,
+        doc?._rawData
+      );
       await this.database.put(
         realPath,
-        { ...values, ..._tinaEmbeds },
+        { ...oldDoc, ...params },
         collection.name
       );
       return this.getDocument(realPath);
@@ -5171,17 +5221,35 @@ var Resolver = class {
           await this.deleteDocument(realPath);
           if (await this.hasReferences(realPath, collection)) {
             const collRefs = await this.findReferences(realPath, collection);
-            for (const [collection2, refFields] of Object.entries(collRefs)) {
-              for (const [refPath, refs] of Object.entries(refFields)) {
-                let refDoc = await this.getRaw(refPath);
-                for (const ref of refs) {
-                  refDoc = updateObjectWithJsonPath(
+            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,
-                    ref.path.join("."),
+                    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
+                  );
                 }
-                await this.database.put(refPath, refDoc, collection2);
               }
             }
           }
@@ -5201,26 +5269,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, refFields] of Object.entries(collRefs)) {
-            for (const [refPath, refs] of Object.entries(refFields)) {
-              let refDoc = await this.getRaw(refPath);
-              for (const ref of refs) {
-                refDoc = updateObjectWithJsonPath(
-                  refDoc,
-                  ref.path.join("."),
+          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
+                );
               }
-              await this.database.put(refPath, refDoc, collection2);
             }
           }
           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,
@@ -5346,35 +5437,30 @@ var Resolver = class {
      */
     this.hasReferences = async (id, c) => {
       let count = 0;
-      const deepRefs = this.tinaSchema.findReferences(c.name);
-      for (const [collection, refs] of Object.entries(deepRefs)) {
-        for (const ref of refs) {
-          await this.database.query(
-            {
-              collection,
-              filterChain: makeFilterChain({
-                conditions: [
-                  {
-                    filterPath: ref.path.join("."),
-                    filterExpression: {
-                      _type: "reference",
-                      _list: false,
-                      eq: id
-                    }
-                  }
-                ]
-              }),
-              sort: ref.field.name
-            },
-            (refId) => {
-              count++;
-              return refId;
-            }
-          );
-          if (count) {
-            return true;
-          }
+      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;
     };
@@ -5382,46 +5468,41 @@ var Resolver = class {
      * 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 references to the document in the form of a map of collection names to a list of fields that reference the document
+     * @returns a map of references to the document
      */
     this.findReferences = async (id, c) => {
       const references = {};
-      const deepRefs = this.tinaSchema.findReferences(c.name);
-      for (const [collection, refs] of Object.entries(deepRefs)) {
-        for (const ref of refs) {
-          await this.database.query(
-            {
-              collection,
-              filterChain: makeFilterChain({
-                conditions: [
-                  {
-                    filterPath: ref.path.join("."),
-                    filterExpression: {
-                      _type: "reference",
-                      _list: false,
-                      eq: id
-                    }
-                  }
-                ]
-              }),
-              sort: ref.field.name
-            },
-            (refId) => {
-              if (!references[collection]) {
-                references[collection] = {};
-              }
-              if (!references[collection][refId]) {
-                references[collection][refId] = [];
+      await this.database.query(
+        {
+          collection: c.name,
+          filterChain: makeFilterChain({
+            conditions: [
+              {
+                filterPath: REFS_REFERENCE_FIELD,
+                filterExpression: {
+                  _type: "string",
+                  _list: false,
+                  eq: id
+                }
               }
-              references[collection][refId].push({
-                path: ref.path,
-                field: ref.field
-              });
-              return refId;
-            }
-          );
+            ]
+          }),
+          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) => {
@@ -5492,15 +5573,13 @@ var Resolver = class {
             break;
           case "rich-text":
             accum[fieldName] = stringifyMDX(
-              // @ts-ignore
               fieldValue,
               field,
               (fieldValue2) => resolveMediaCloudToRelative(
                 fieldValue2,
                 this.config,
                 this.tinaSchema.schema
-              ),
-              this.context
+              )
             );
             break;
           case "reference":
@@ -6167,6 +6246,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) {
@@ -6195,6 +6275,14 @@ var Database = class {
       let delOps = [];
       if (!isGitKeep(normalizedPath, collection)) {
         putOps = [
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection?.name,
+            collectionReferences,
+            dataFields,
+            "put",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection?.name,
@@ -6218,6 +6306,14 @@ var Database = class {
           SUBLEVEL_OPTIONS
         ).get(normalizedPath);
         delOps = existingItem ? [
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection?.name,
+            collectionReferences,
+            existingItem,
+            "del",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection?.name,
@@ -6265,6 +6361,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);
@@ -6312,6 +6409,14 @@ var Database = class {
           let delOps = [];
           if (!isGitKeep(normalizedPath, collection)) {
             putOps = [
+              ...makeRefOpsForDocument(
+                normalizedPath,
+                collectionName,
+                collectionReferences,
+                dataFields,
+                "put",
+                level
+              ),
               ...makeIndexOpsForDocument(
                 normalizedPath,
                 collectionName,
@@ -6335,6 +6440,14 @@ var Database = class {
               SUBLEVEL_OPTIONS
             ).get(normalizedPath);
             delOps = existingItem ? [
+              ...makeRefOpsForDocument(
+                normalizedPath,
+                collectionName,
+                collectionReferences,
+                existingItem,
+                "del",
+                level
+              ),
               ...makeIndexOpsForDocument(
                 normalizedPath,
                 collectionName,
@@ -6497,6 +6610,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) => {
@@ -6506,8 +6635,23 @@ 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) {
@@ -6658,29 +6802,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,
@@ -6826,6 +6977,7 @@ 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) {
@@ -6844,6 +6996,14 @@ var Database = class {
           collection.path || ""
         );
         await this.contentLevel.batch([
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection.name,
+            collectionReferences,
+            item,
+            "del",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection.name,
@@ -6921,7 +7081,13 @@ var Database = class {
               );
             }
           } else {
-            await _indexContent(this, level, contentPaths, enqueueOps, collection);
+            await _indexContent(
+              this,
+              level,
+              contentPaths,
+              enqueueOps,
+              collection
+            );
           }
         }
       );
@@ -7071,14 +7237,16 @@ 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) {
     templateInfo = tinaSchema.getTemplatesForCollectable(collection);
   }
   const folderTreeBuilder = new FolderTreeBuilder();
-  await sequential(documentPaths, async (filepath) => {
+  async function processFile(filepath) {
     try {
+      console.log(`Preloading ${filepath}`);
       const aliasedData = await loadAndParseWithAliases(
         database.bridge,
         filepath,
@@ -7092,12 +7260,62 @@ 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);
+      await new Promise((res) => setTimeout(res, 5e3));
+      console.log("Ceasing preload");
+      if (item) {
+        console.log("Running deletion operations");
+        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,
@@ -7134,7 +7352,10 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
         stack: error.stack
       });
     }
-  });
+  }
+  ;
+  const filePromises = documentPaths.map(processFile);
+  await Promise.all(filePromises);
   if (collection) {
     await enqueueOps(
       makeFolderOpsForCollection(
@@ -7161,6 +7382,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) {
@@ -7184,6 +7406,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,