@tinacms/graphql 0.0.0-d7c745e-20250102002342 → 0.0.0-d9672bc-20250218033222

package/dist/index.js

@@ -1095,41 +1095,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("");
 };
@@ -2965,12 +2930,13 @@ var filterSelections = (arr) => {
 };
 
 // src/schema/createSchema.ts
-var import_schema_tools2 = require("@tinacms/schema-tools");
+var import_schema_tools3 = require("@tinacms/schema-tools");
 
 // src/schema/validate.ts
+var import_schema_tools = require("@tinacms/schema-tools");
 var import_lodash2 = __toESM(require("lodash.clonedeep"));
 var yup2 = __toESM(require("yup"));
-var import_schema_tools = require("@tinacms/schema-tools");
+var import_schema_tools2 = require("@tinacms/schema-tools");
 var FIELD_TYPES = [
   "string",
   "number",
@@ -2983,7 +2949,7 @@ var FIELD_TYPES = [
   "password"
 ];
 var validateSchema = async (schema) => {
-  const schema2 = addNamespaceToSchema(
+  const schema2 = (0, import_schema_tools.addNamespaceToSchema)(
     (0, import_lodash2.default)(schema)
   );
   const collections = await sequential(
@@ -2992,7 +2958,7 @@ var validateSchema = async (schema) => {
   );
   validationCollectionsPathAndMatch(collections);
   if (schema2.config) {
-    const config = (0, import_schema_tools.validateTinaCloudSchemaConfig)(schema2.config);
+    const config = (0, import_schema_tools2.validateTinaCloudSchemaConfig)(schema2.config);
     return {
       collections,
       config
@@ -3124,7 +3090,7 @@ var validateField = async (field) => {
 // package.json
 var package_default = {
   name: "@tinacms/graphql",
-  version: "1.5.9",
+  version: "1.5.12",
   main: "dist/index.js",
   module: "dist/index.mjs",
   typings: "dist/index.d.ts",
@@ -3151,8 +3117,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",
@@ -3193,7 +3159,6 @@ 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",
@@ -3204,13 +3169,13 @@ var package_default = {
     "@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.3"
+    typescript: "^5.6.3",
+    vite: "^4.3.9",
+    vitest: "^0.32.2",
+    zod: "^3.23.8"
   }
 };
 
@@ -3225,7 +3190,7 @@ var createSchema = async ({
   if (flags && flags.length > 0) {
     meta["flags"] = flags;
   }
-  return new import_schema_tools2.TinaSchema({
+  return new import_schema_tools3.TinaSchema({
     version: {
       fullVersion: package_default.version,
       major,
@@ -3723,7 +3688,7 @@ var import_path2 = __toESM(require("path"));
 var import_toml = __toESM(require("@iarna/toml"));
 var import_js_yaml = __toESM(require("js-yaml"));
 var import_gray_matter = __toESM(require("gray-matter"));
-var import_schema_tools3 = require("@tinacms/schema-tools");
+var import_schema_tools4 = require("@tinacms/schema-tools");
 var import_micromatch = __toESM(require("micromatch"));
 var import_path = __toESM(require("path"));
 
@@ -3936,7 +3901,7 @@ var scanAllContent = async (tinaSchema, bridge, callback) => {
   const filesSeen = /* @__PURE__ */ new Map();
   const duplicateFiles = /* @__PURE__ */ new Set();
   await sequential(tinaSchema.getCollections(), async (collection) => {
-    const normalPath = (0, import_schema_tools3.normalizePath)(collection.path);
+    const normalPath = (0, import_schema_tools4.normalizePath)(collection.path);
     const format = collection.format || "md";
     const documentPaths = await bridge.glob(normalPath, format);
     const matches = tinaSchema.getMatches({ collection });
@@ -4048,7 +4013,7 @@ var getTemplateForFile = (templateInfo, data) => {
   throw new Error(`Unable to determine template`);
 };
 var loadAndParseWithAliases = async (bridge, filepath, collection, templateInfo) => {
-  const dataString = await bridge.get((0, import_schema_tools3.normalizePath)(filepath));
+  const dataString = await bridge.get((0, import_schema_tools4.normalizePath)(filepath));
   const data = parseFile(
     dataString,
     import_path.default.extname(filepath),
@@ -4070,6 +4035,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) {
@@ -4527,7 +4495,7 @@ var FolderTreeBuilder = class {
     return this._tree;
   }
   update(documentPath, collectionPath) {
-    let folderPath = import_path2.default.dirname((0, import_schema_tools3.normalizePath)(documentPath));
+    let folderPath = import_path2.default.dirname((0, import_schema_tools4.normalizePath)(documentPath));
     if (folderPath === ".") {
       folderPath = "";
     }
@@ -4540,7 +4508,7 @@ var FolderTreeBuilder = class {
       if (!this._tree[current2]) {
         this._tree[current2] = /* @__PURE__ */ new Set();
       }
-      this._tree[current2].add((0, import_schema_tools3.normalizePath)(import_path2.default.join(current2, part)));
+      this._tree[current2].add((0, import_schema_tools4.normalizePath)(import_path2.default.join(current2, part)));
       parent.push(part);
     });
     const current = parent.join("/");
@@ -4643,6 +4611,41 @@ 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 = (0, import_jsonpath_plus.JSONPath)({ path: path7, json: data });
+        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)) {
@@ -5260,17 +5263,15 @@ 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(
-                    refDoc,
-                    ref.path.join("."),
-                    null
-                  );
+            for (const [collection2, docsWithRefs] of Object.entries(collRefs)) {
+              for (const [pathToDocWithRef, referencePaths] of Object.entries(
+                docsWithRefs
+              )) {
+                let refDoc = await this.getRaw(pathToDocWithRef);
+                for (const path7 of referencePaths) {
+                  refDoc = updateObjectWithJsonPath(refDoc, path7, null);
                 }
-                await this.database.put(refPath, refDoc, collection2);
+                await this.database.put(pathToDocWithRef, refDoc, collection2);
               }
             }
           }
@@ -5293,17 +5294,19 @@ var Resolver = class {
           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);
+              for (const path7 of referencePaths) {
+                docWithRef = updateObjectWithJsonPath(
+                  docWithRef,
+                  path7,
                   newRealPath
                 );
               }
-              await this.database.put(refPath, refDoc, collection2);
+              await this.database.put(pathToDocWithRef, docWithRef, collection2);
             }
           }
           return this.getDocument(newRealPath);
@@ -5435,35 +5438,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;
     };
@@ -5471,46 +5469,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 == null ? void 0 : rawItem[REFS_PATH_FIELD];
+          if (referencePath) {
+            references[c.name][refId].push(referencePath);
+          }
+          return refId;
         }
-      }
+      );
       return references;
     };
     this.buildFieldMutations = async (fieldParams, template, existingData) => {
@@ -6234,7 +6227,7 @@ var Database = class {
         const contentObject = await level.sublevel(
           CONTENT_ROOT_PREFIX,
           SUBLEVEL_OPTIONS
-        ).get((0, import_schema_tools3.normalizePath)(filepath));
+        ).get((0, import_schema_tools4.normalizePath)(filepath));
         if (!contentObject) {
           throw new NotFoundError(`Unable to find record ${filepath}`);
         }
@@ -6246,6 +6239,7 @@ var Database = class {
       }
     };
     this.addPendingDocument = async (filepath, data) => {
+      var _a;
       await this.initLevel();
       const dataFields = await this.formatBodyOnPayload(filepath, data);
       const collection = await this.collectionForPath(filepath);
@@ -6259,7 +6253,8 @@ var Database = class {
       );
       const indexDefinitions = await this.getIndexDefinitions(this.contentLevel);
       const collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
-      const normalizedPath = (0, import_schema_tools3.normalizePath)(filepath);
+      const collectionReferences = (_a = await this.getCollectionReferences()) == null ? void 0 : _a[collection.name];
+      const normalizedPath = (0, import_schema_tools4.normalizePath)(filepath);
       if (!(collection == null ? void 0 : collection.isDetached)) {
         if (this.bridge) {
           await this.bridge.put(normalizedPath, stringifiedFile);
@@ -6287,6 +6282,14 @@ var Database = class {
       let delOps = [];
       if (!isGitKeep(normalizedPath, collection)) {
         putOps = [
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection == null ? void 0 : collection.name,
+            collectionReferences,
+            dataFields,
+            "put",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection == null ? void 0 : collection.name,
@@ -6310,6 +6313,14 @@ var Database = class {
           SUBLEVEL_OPTIONS
         ).get(normalizedPath);
         delOps = existingItem ? [
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection == null ? void 0 : collection.name,
+            collectionReferences,
+            existingItem,
+            "del",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection == null ? void 0 : collection.name,
@@ -6345,7 +6356,7 @@ var Database = class {
       await level.batch(ops);
     };
     this.put = async (filepath, data, collectionName) => {
-      var _a, _b;
+      var _a, _b, _c;
       await this.initLevel();
       try {
         if (SYSTEM_FILES.includes(filepath)) {
@@ -6358,13 +6369,14 @@ var Database = class {
             );
             collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collectionName];
           }
-          const normalizedPath = (0, import_schema_tools3.normalizePath)(filepath);
+          const collectionReferences = (_a = await this.getCollectionReferences()) == null ? void 0 : _a[collectionName];
+          const normalizedPath = (0, import_schema_tools4.normalizePath)(filepath);
           const dataFields = await this.formatBodyOnPayload(filepath, data);
           const collection = await this.collectionForPath(filepath);
           if (!collection) {
             throw new import_graphql6.GraphQLError(`Unable to find collection for ${filepath}.`);
           }
-          if (((_a = collection.match) == null ? void 0 : _a.exclude) || ((_b = collection.match) == null ? void 0 : _b.include)) {
+          if (((_b = collection.match) == null ? void 0 : _b.exclude) || ((_c = collection.match) == null ? void 0 : _c.include)) {
             const matches = this.tinaSchema.getMatches({ collection });
             const match = import_micromatch2.default.isMatch(filepath, matches);
             if (!match) {
@@ -6405,6 +6417,14 @@ var Database = class {
           let delOps = [];
           if (!isGitKeep(normalizedPath, collection)) {
             putOps = [
+              ...makeRefOpsForDocument(
+                normalizedPath,
+                collectionName,
+                collectionReferences,
+                dataFields,
+                "put",
+                level
+              ),
               ...makeIndexOpsForDocument(
                 normalizedPath,
                 collectionName,
@@ -6428,6 +6448,14 @@ var Database = class {
               SUBLEVEL_OPTIONS
             ).get(normalizedPath);
             delOps = existingItem ? [
+              ...makeRefOpsForDocument(
+                normalizedPath,
+                collectionName,
+                collectionReferences,
+                existingItem,
+                "del",
+                level
+              ),
               ...makeIndexOpsForDocument(
                 normalizedPath,
                 collectionName,
@@ -6532,7 +6560,7 @@ var Database = class {
     };
     this.getLookup = async (returnType) => {
       await this.initLevel();
-      const lookupPath = (0, import_schema_tools3.normalizePath)(
+      const lookupPath = (0, import_schema_tools4.normalizePath)(
         import_node_path.default.join(this.getGeneratedFolder(), `_lookup.json`)
       );
       if (!this._lookup) {
@@ -6545,7 +6573,7 @@ var Database = class {
     };
     this.getGraphQLSchema = async () => {
       await this.initLevel();
-      const graphqlPath = (0, import_schema_tools3.normalizePath)(
+      const graphqlPath = (0, import_schema_tools4.normalizePath)(
         import_node_path.default.join(this.getGeneratedFolder(), `_graphql.json`)
       );
       return await this.contentLevel.sublevel(
@@ -6558,7 +6586,7 @@ var Database = class {
       if (!this.bridge) {
         throw new Error(`No bridge configured`);
       }
-      const graphqlPath = (0, import_schema_tools3.normalizePath)(
+      const graphqlPath = (0, import_schema_tools4.normalizePath)(
         import_node_path.default.join(this.getGeneratedFolder(), `_graphql.json`)
       );
       const _graphql = await this.bridge.get(graphqlPath);
@@ -6566,7 +6594,7 @@ var Database = class {
     };
     this.getTinaSchema = async (level) => {
       await this.initLevel();
-      const schemaPath = (0, import_schema_tools3.normalizePath)(
+      const schemaPath = (0, import_schema_tools4.normalizePath)(
         import_node_path.default.join(this.getGeneratedFolder(), `_schema.json`)
       );
       return await (level || this.contentLevel).sublevel(
@@ -6582,7 +6610,7 @@ var Database = class {
       const schema = existingSchema || await this.getTinaSchema(level || this.contentLevel);
       if (!schema) {
         throw new Error(
-          `Unable to get schema from level db: ${(0, import_schema_tools3.normalizePath)(
+          `Unable to get schema from level db: ${(0, import_schema_tools4.normalizePath)(
             import_node_path.default.join(this.getGeneratedFolder(), `_schema.json`)
           )}`
         );
@@ -6590,6 +6618,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) => {
@@ -6599,8 +6643,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) {
@@ -6752,29 +6811,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,
@@ -6799,7 +6865,7 @@ var Database = class {
           try {
             lookup = lookupFromLockFile || JSON.parse(
               await this.bridge.get(
-                (0, import_schema_tools3.normalizePath)(
+                (0, import_schema_tools4.normalizePath)(
                   import_node_path.default.join(this.getGeneratedFolder(), "_lookup.json")
                 )
               )
@@ -6824,15 +6890,15 @@ var Database = class {
           }
           const contentRootLevel = nextLevel.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS);
           await contentRootLevel.put(
-            (0, import_schema_tools3.normalizePath)(import_node_path.default.join(this.getGeneratedFolder(), "_graphql.json")),
+            (0, import_schema_tools4.normalizePath)(import_node_path.default.join(this.getGeneratedFolder(), "_graphql.json")),
             graphQLSchema
           );
           await contentRootLevel.put(
-            (0, import_schema_tools3.normalizePath)(import_node_path.default.join(this.getGeneratedFolder(), "_schema.json")),
+            (0, import_schema_tools4.normalizePath)(import_node_path.default.join(this.getGeneratedFolder(), "_schema.json")),
             tinaSchema.schema
           );
           await contentRootLevel.put(
-            (0, import_schema_tools3.normalizePath)(import_node_path.default.join(this.getGeneratedFolder(), "_lookup.json")),
+            (0, import_schema_tools4.normalizePath)(import_node_path.default.join(this.getGeneratedFolder(), "_lookup.json")),
             lookup
           );
           const result = await this._indexAllContent(
@@ -6914,18 +6980,20 @@ var Database = class {
       }
     };
     this.delete = async (filepath) => {
+      var _a;
       await this.initLevel();
       const collection = await this.collectionForPath(filepath);
       if (!collection) {
         throw new Error(`No collection found for path: ${filepath}`);
       }
       const indexDefinitions = await this.getIndexDefinitions(this.contentLevel);
+      const collectionReferences = (_a = await this.getCollectionReferences()) == null ? void 0 : _a[collection.name];
       const collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
       let level = this.contentLevel;
       if (collection == null ? void 0 : collection.isDetached) {
         level = this.appLevel.sublevel(collection == null ? void 0 : collection.name, SUBLEVEL_OPTIONS);
       }
-      const normalizedPath = (0, import_schema_tools3.normalizePath)(filepath);
+      const normalizedPath = (0, import_schema_tools4.normalizePath)(filepath);
       const rootSublevel = level.sublevel(
         CONTENT_ROOT_PREFIX,
         SUBLEVEL_OPTIONS
@@ -6938,6 +7006,14 @@ var Database = class {
           collection.path || ""
         );
         await this.contentLevel.batch([
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection.name,
+            collectionReferences,
+            item,
+            "del",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection.name,
@@ -7155,6 +7231,7 @@ var hashPasswordValues = async (data, passwordFields) => Promise.all(
 );
 var isGitKeep = (filepath, collection) => filepath.endsWith(`.gitkeep.${(collection == null ? void 0 : collection.format) || "md"}`);
 var _indexContent = async (database, level, documentPaths, enqueueOps, collection, passwordFields) => {
+  var _a;
   let collectionIndexDefinitions;
   let collectionPath;
   if (collection) {
@@ -7165,6 +7242,7 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
     }
     collectionPath = collection.path;
   }
+  const collectionReferences = (_a = await database.getCollectionReferences()) == null ? void 0 : _a[collection == null ? void 0 : collection.name];
   const tinaSchema = await database.getSchema();
   let templateInfo = null;
   if (collection) {
@@ -7185,13 +7263,60 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
       if (passwordFields == null ? void 0 : passwordFields.length) {
         await hashPasswordValues(aliasedData, passwordFields);
       }
-      const normalizedPath = (0, import_schema_tools3.normalizePath)(filepath);
+      const normalizedPath = (0, import_schema_tools4.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 == null ? void 0 : 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 == null ? void 0 : collection.name,
+            collectionReferences,
+            aliasedData,
+            "put",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection == null ? void 0 : collection.name,
@@ -7242,6 +7367,7 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
   }
 };
 var _deleteIndexContent = async (database, documentPaths, enqueueOps, collection) => {
+  var _a;
   if (!documentPaths.length) {
     return;
   }
@@ -7255,6 +7381,7 @@ var _deleteIndexContent = async (database, documentPaths, enqueueOps, collection
       throw new Error(`No indexDefinitions for collection ${collection.name}`);
     }
   }
+  const collectionReferences = (_a = await database.getCollectionReferences()) == null ? void 0 : _a[collection == null ? void 0 : collection.name];
   const tinaSchema = await database.getSchema();
   let templateInfo = null;
   if (collection) {
@@ -7266,7 +7393,7 @@ var _deleteIndexContent = async (database, documentPaths, enqueueOps, collection
   );
   const folderTreeBuilder = new FolderTreeBuilder();
   await sequential(documentPaths, async (filepath) => {
-    const itemKey = (0, import_schema_tools3.normalizePath)(filepath);
+    const itemKey = (0, import_schema_tools4.normalizePath)(filepath);
     const item = await rootLevel.get(itemKey);
     if (item) {
       const folderKey = folderTreeBuilder.update(
@@ -7278,6 +7405,14 @@ var _deleteIndexContent = async (database, documentPaths, enqueueOps, collection
         item
       ) : item;
       await enqueueOps([
+        ...makeRefOpsForDocument(
+          itemKey,
+          collection == null ? void 0 : collection.name,
+          collectionReferences,
+          aliasedData,
+          "del",
+          database.contentLevel
+        ),
         ...makeIndexOpsForDocument(
           itemKey,
           collection.name,
@@ -7353,14 +7488,14 @@ var getChangedFiles = async ({
   const rootDir = await findGitRoot(dir);
   let pathPrefix = "";
   if (rootDir !== dir) {
-    pathPrefix = (0, import_schema_tools3.normalizePath)(dir.substring(rootDir.length + 1));
+    pathPrefix = (0, import_schema_tools4.normalizePath)(dir.substring(rootDir.length + 1));
   }
   await import_isomorphic_git.default.walk({
     fs: fs4,
     dir: rootDir,
     trees: [import_isomorphic_git.default.TREE({ ref: from }), import_isomorphic_git.default.TREE({ ref: to })],
     map: async function(filename, [A, B]) {
-      const relativePath = (0, import_schema_tools3.normalizePath)(filename).substring(pathPrefix.length);
+      const relativePath = (0, import_schema_tools4.normalizePath)(filename).substring(pathPrefix.length);
       let matches = false;
       for (const [key, matcher] of Object.entries(pathFilter)) {
         if (relativePath.startsWith(key)) {