@tinacms/graphql 2.0.3 → 2.0.4

package/dist/index.js

@@ -45,8 +45,8 @@ var btoa = (string2) => {
 var lastItem = (arr) => {
   return arr[arr.length - 1];
 };
-var get = (obj, path7, defaultValue = void 0) => {
-  const travel = (regexp) => String.prototype.split.call(path7, regexp).filter(Boolean).reduce(
+var get = (obj, path8, defaultValue = void 0) => {
+  const travel = (regexp) => String.prototype.split.call(path8, regexp).filter(Boolean).reduce(
     (res, key) => res !== null && res !== void 0 ? res[key] : res,
     obj
   );
@@ -3026,7 +3026,7 @@ var validateField = async (field) => {
 var package_default = {
   name: "@tinacms/graphql",
   type: "module",
-  version: "2.0.3",
+  version: "2.0.4",
   main: "dist/index.js",
   module: "./dist/index.js",
   files: [
@@ -3308,7 +3308,12 @@ var _buildSchema = async (builder, tinaSchema) => {
 };
 
 // src/resolve.ts
-import { graphql, buildASTSchema, getNamedType, GraphQLError as GraphQLError4 } from "graphql";
+import {
+  graphql,
+  buildASTSchema,
+  getNamedType,
+  GraphQLError as GraphQLError4
+} from "graphql";
 
 // src/resolver/index.ts
 import path3 from "path";
@@ -3647,17 +3652,17 @@ var scanAllContent = async (tinaSchema, bridge, callback) => {
     const documentPaths = await bridge.glob(normalPath, format);
     const matches = tinaSchema.getMatches({ collection });
     const filteredPaths = matches.length > 0 ? micromatch(documentPaths, matches) : documentPaths;
-    filteredPaths.forEach((path7) => {
-      if (filesSeen.has(path7)) {
-        filesSeen.get(path7).push(collection.name);
-        duplicateFiles.add(path7);
+    filteredPaths.forEach((path8) => {
+      if (filesSeen.has(path8)) {
+        filesSeen.get(path8).push(collection.name);
+        duplicateFiles.add(path8);
       } else {
-        filesSeen.set(path7, [collection.name]);
+        filesSeen.set(path8, [collection.name]);
       }
     });
-    duplicateFiles.forEach((path7) => {
+    duplicateFiles.forEach((path8) => {
       warnings.push(
-        `"${path7}" Found in multiple collections: ${filesSeen.get(path7).map((collection2) => `"${collection2}"`).join(
+        `"${path8}" Found in multiple collections: ${filesSeen.get(path8).map((collection2) => `"${collection2}"`).join(
           ", "
         )}. This can cause unexpected behavior. We recommend updating the \`match\` property of those collections so that each file is in only one collection.
 This will be an error in the future. See https://tina.io/docs/errors/file-in-mutpliple-collections/
@@ -4220,9 +4225,9 @@ var makeFilterSuffixes = (filterChain, index) => {
   }
 };
 var FOLDER_ROOT = "~";
-var stripCollectionFromPath = (collectionPath, path7) => {
+var stripCollectionFromPath = (collectionPath, path8) => {
   const collectionPathParts = collectionPath.split("/");
-  const pathParts = path7.split("/");
+  const pathParts = path8.split("/");
   const strippedPathParts = pathParts.slice(collectionPathParts.length);
   return strippedPathParts.join("/");
 };
@@ -4278,13 +4283,13 @@ var makeFolderOpsForCollection = (folderTree, collection, indexDefinitions, opTy
       SUBLEVEL_OPTIONS
     );
     let folderSortingIdx = 0;
-    for (const path7 of Array.from(folder).sort()) {
+    for (const path8 of Array.from(folder).sort()) {
       for (const [sort] of Object.entries(indexDefinitions)) {
         const indexSublevel = folderCollectionSublevel.sublevel(
           sort,
           SUBLEVEL_OPTIONS
         );
-        const subFolderKey = sha.hex(path7);
+        const subFolderKey = sha.hex(path8);
         if (sort === DEFAULT_COLLECTION_SORT_KEY) {
           result.push({
             type: opType,
@@ -4366,8 +4371,8 @@ var makeRefOpsForDocument = (filepath, collection, references, data, opType, lev
         SUBLEVEL_OPTIONS
       );
       const references2 = {};
-      for (const path7 of referencePaths) {
-        const ref = JSONPath({ path: path7, json: data });
+      for (const path8 of referencePaths) {
+        const ref = JSONPath({ path: path8, json: data });
         if (!ref) {
           continue;
         }
@@ -4377,24 +4382,24 @@ var makeRefOpsForDocument = (filepath, collection, references, data, opType, lev
               continue;
             }
             if (references2[r]) {
-              references2[r].push(path7);
+              references2[r].push(path8);
             } else {
-              references2[r] = [path7];
+              references2[r] = [path8];
             }
           }
         } else {
           if (references2[ref]) {
-            references2[ref].push(path7);
+            references2[ref].push(path8);
           } else {
-            references2[ref] = [path7];
+            references2[ref] = [path8];
           }
         }
       }
       for (const ref of Object.keys(references2)) {
-        for (const path7 of references2[ref]) {
+        for (const path8 of references2[ref]) {
           result.push({
             type: opType,
-            key: `${ref}${INDEX_KEY_FIELD_SEPARATOR}${path7}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`,
+            key: `${ref}${INDEX_KEY_FIELD_SEPARATOR}${path8}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`,
             sublevel: refSublevel,
             value: opType === "put" ? {} : void 0
           });
@@ -4661,9 +4666,9 @@ var resolveMediaRelativeToCloud = (value, config = { useRelativeMedia: true }, s
     return value;
   }
 };
-var cleanUpSlashes = (path7) => {
-  if (path7) {
-    return `/${path7.replace(/^\/+|\/+$/gm, "")}`;
+var cleanUpSlashes = (path8) => {
+  if (path8) {
+    return `/${path8.replace(/^\/+|\/+$/gm, "")}`;
   }
   return "";
 };
@@ -4873,17 +4878,17 @@ var transformDocumentIntoPayload = async (fullPath, rawData, tinaSchema, config,
     throw e;
   }
 };
-var updateObjectWithJsonPath = (obj, path7, oldValue, newValue) => {
+var updateObjectWithJsonPath = (obj, path8, oldValue, newValue) => {
   let updated = false;
-  if (!path7.includes(".") && !path7.includes("[")) {
-    if (path7 in obj && obj[path7] === oldValue) {
-      obj[path7] = newValue;
+  if (!path8.includes(".") && !path8.includes("[")) {
+    if (path8 in obj && obj[path8] === oldValue) {
+      obj[path8] = newValue;
       updated = true;
     }
     return { object: obj, updated };
   }
-  const parentPath = path7.replace(/\.[^.\[\]]+$/, "");
-  const keyToUpdate = path7.match(/[^.\[\]]+$/)[0];
+  const parentPath = path8.replace(/\.[^.\[\]]+$/, "");
+  const keyToUpdate = path8.match(/[^.\[\]]+$/)[0];
   const parents = JSONPath2({
     path: parentPath,
     json: obj,
@@ -4913,7 +4918,7 @@ var Resolver = class {
   database;
   tinaSchema;
   isAudit;
-  resolveCollection = async (args, collectionName, hasDocuments) => {
+  resolveCollection = async (_args, collectionName, hasDocuments) => {
     const collection = this.tinaSchema.getCollection(collectionName);
     const extraFields = {};
     return {
@@ -5080,38 +5085,296 @@ var Resolver = class {
       }
     }
   };
-  createResolveDocument = async ({
-    collection,
-    realPath,
-    args,
-    isAddPendingDocument
+  resolveAddPendingDocument = async ({
+    collectionName,
+    relativePath,
+    templateName
   }) => {
-    if (isAddPendingDocument === true) {
-      const templateInfo = this.tinaSchema.getTemplatesForCollectable(collection);
-      switch (templateInfo.type) {
-        case "object":
-          await this.database.addPendingDocument(realPath, {});
-          break;
-        case "union":
-          const templateString = args.template;
-          const template = templateInfo.templates.find(
-            (template2) => lastItem(template2.namespace) === templateString
+    const collection = this.getCollectionWithName(collectionName);
+    const realPath = path3.join(collection.path, relativePath);
+    const alreadyExists = await this.database.documentExists(realPath);
+    if (alreadyExists) {
+      throw new Error(`Unable to add document, ${realPath} already exists`);
+    }
+    const templateInfo = this.tinaSchema.getTemplatesForCollectable(collection);
+    switch (templateInfo.type) {
+      case "object":
+        await this.database.addPendingDocument(realPath, {});
+        break;
+      case "union":
+        if (!templateName) {
+          throw new Error(
+            `Must specify a template when creating content for a collection with multiple templates. Possible templates are: ${templateInfo.templates.map((t) => lastItem(t.namespace)).join(" ")}`
           );
-          if (!args.template) {
-            throw new Error(
-              `Must specify a template when creating content for a collection with multiple templates. Possible templates are: ${templateInfo.templates.map((t) => lastItem(t.namespace)).join(" ")}`
+        }
+        const template = templateInfo.templates.find(
+          (template2) => lastItem(template2.namespace) === templateName
+        );
+        if (!template) {
+          throw new Error(
+            `Expected to find template named ${templateName} in collection "${collection.name}" but none was found. Possible templates are: ${templateInfo.templates.map((t) => lastItem(t.namespace)).join(" ")}`
+          );
+        }
+        await this.database.addPendingDocument(realPath, {
+          _template: lastItem(template.namespace)
+        });
+    }
+    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
+   */
+  resolveLegacyValues = (oldDoc, collection) => {
+    const legacyValues = {};
+    Object.entries(oldDoc).forEach(([key, value]) => {
+      const reservedKeys = [
+        "$_body",
+        "_collection",
+        "_keepTemplateKey",
+        "_template",
+        "_relativePath",
+        "_id"
+      ];
+      if (reservedKeys.includes(key)) {
+        return;
+      }
+      if (oldDoc._template && collection.templates) {
+        const template = collection.templates?.find(
+          ({ name }) => name === oldDoc._template
+        );
+        if (template) {
+          if (!template.fields.find(({ name }) => name === key)) {
+            legacyValues[key] = value;
+          }
+        }
+      }
+      if (oldDoc._collection && collection.fields) {
+        if (!collection.fields.find(({ name }) => name === key)) {
+          legacyValues[key] = value;
+        }
+      }
+    });
+    return legacyValues;
+  };
+  getCollectionWithName = (collectionName) => {
+    const collectionNames = this.tinaSchema.getCollections().map((item) => item.name);
+    if (!collectionNames.includes(collectionName)) {
+      throw new Error(
+        `"collection" must be one of: [${collectionNames.join(
+          ", "
+        )}] but got ${collectionName}`
+      );
+    }
+    return this.tinaSchema.getCollection(collectionName);
+  };
+  /*
+   * Used for getDocument, get<Collection>Document.
+   */
+  resolveRetrievedDocument = async ({
+    collectionName,
+    relativePath
+  }) => {
+    const collection = this.getCollectionWithName(collectionName);
+    const realPath = path3.join(collection.path, relativePath);
+    return this.getDocument(realPath, {
+      collection,
+      checkReferences: true
+    });
+  };
+  /*
+   * Used for createFolder, create<Collection>Folder
+   */
+  resolveCreateFolder = async ({
+    collectionName,
+    relativePath
+  }) => {
+    const collection = this.getCollectionWithName(collectionName);
+    const realPath = path3.join(
+      collection.path,
+      relativePath,
+      `.gitkeep.${collection.format || "md"}`
+    );
+    const alreadyExists = await this.database.documentExists(realPath);
+    if (alreadyExists) {
+      throw new Error(`Unable to add folder, ${realPath} already exists`);
+    }
+    await this.database.put(
+      realPath,
+      { _is_tina_folder_placeholder: true },
+      collection.name
+    );
+    return this.getDocument(realPath);
+  };
+  resolveCreateDocument = async ({
+    collectionName,
+    relativePath,
+    body
+  }) => {
+    const collection = this.getCollectionWithName(collectionName);
+    const realPath = path3.join(collection.path, relativePath);
+    const alreadyExists = await this.database.documentExists(realPath);
+    if (alreadyExists) {
+      throw new Error(`Unable to add document, ${realPath} already exists`);
+    }
+    const params = await this.buildObjectMutations(body, collection);
+    await this.database.put(realPath, params, collection.name);
+    return this.getDocument(realPath);
+  };
+  resolveUpdateDocument = async ({
+    collectionName,
+    relativePath,
+    newRelativePath,
+    newBody
+  }) => {
+    const collection = this.getCollectionWithName(collectionName);
+    const realPath = path3.join(collection.path, relativePath);
+    const alreadyExists = await this.database.documentExists(realPath);
+    if (!alreadyExists) {
+      throw new Error(`Unable to update document, ${realPath} does not exist`);
+    }
+    const doc = await this.getDocument(realPath);
+    if (newRelativePath) {
+      const newRealPath = path3.join(collection?.path, newRelativePath);
+      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 [_collection, docsWithRefs] of Object.entries(collRefs)) {
+        for (const [pathToDocWithRef, referencePaths] of Object.entries(
+          docsWithRefs
+        )) {
+          let docWithRef = await this.getRaw(pathToDocWithRef);
+          let hasUpdate = false;
+          for (const path8 of referencePaths) {
+            const { object: object2, updated } = updateObjectWithJsonPath(
+              docWithRef,
+              path8,
+              realPath,
+              newRealPath
             );
+            docWithRef = object2;
+            hasUpdate = updated || hasUpdate;
           }
-          if (!template) {
-            throw new Error(
-              `Expected to find template named ${templateString} in collection "${collection.name}" but none was found. Possible templates are: ${templateInfo.templates.map((t) => lastItem(t.namespace)).join(" ")}`
+          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.addPendingDocument(realPath, {
-            _template: lastItem(template.namespace)
-          });
+        }
+      }
+      return this.getDocument(newRealPath);
+    }
+    if (!newBody) {
+      throw new Error("Body not provided for updated document.");
+    }
+    const params = await this.buildObjectMutations(
+      newBody,
+      collection,
+      doc?._rawData
+    );
+    const legacyValues = this.resolveLegacyValues(
+      doc?._rawData || {},
+      collection
+    );
+    await this.database.put(
+      realPath,
+      { ...legacyValues, ...params },
+      collection.name
+    );
+    return this.getDocument(realPath);
+  };
+  resolveDeleteDocument = async ({
+    collectionName,
+    relativePath
+  }) => {
+    const collection = this.getCollectionWithName(collectionName);
+    const realPath = path3.join(collection.path, relativePath);
+    const alreadyExists = await this.database.documentExists(realPath);
+    if (!alreadyExists) {
+      throw new Error(`Unable to delete document, ${realPath} does not exist`);
+    }
+    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 [_collection, docsWithRefs] of Object.entries(collRefs)) {
+        for (const [pathToDocWithRef, referencePaths] of Object.entries(
+          docsWithRefs
+        )) {
+          let refDoc = await this.getRaw(pathToDocWithRef);
+          let hasUpdate = false;
+          for (const path8 of referencePaths) {
+            const { object: object2, updated } = updateObjectWithJsonPath(
+              refDoc,
+              path8,
+              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 this.getDocument(realPath);
+    }
+    return doc;
+  };
+  resolveAndValidateCollection = ({
+    collectionName,
+    args,
+    isCollectionSpecific
+  }) => {
+    let collectionLookup = collectionName || void 0;
+    if (!collectionLookup && isCollectionSpecific === false) {
+      assertShape(
+        args,
+        (yup3) => yup3.object({
+          params: yup3.object().required()
+        })
+      );
+      collectionLookup = Object.keys(args.params)[0];
+    }
+    const collection = this.getCollectionWithName(collectionLookup);
+    return { collection };
+  };
+  /**
+   * @deprecated - To be removed in next major version.
+   */
+  createResolveDocument = async ({
+    collection,
+    realPath,
+    args,
+    isAddPendingDocument
+  }) => {
+    if (isAddPendingDocument === true) {
+      return this.resolveAddPendingDocument({
+        collectionName: collection.name,
+        relativePath: path3.relative(collection.path, realPath),
+        templateName: args.template
+      });
     }
     const params = await this.buildObjectMutations(
       // @ts-ignore
@@ -5121,6 +5384,9 @@ var Resolver = class {
     await this.database.put(realPath, params, collection.name);
     return this.getDocument(realPath);
   };
+  /**
+   * @deprecated - To be removed in next major version.
+   */
   updateResolveDocument = async ({
     collection,
     realPath,
@@ -5131,6 +5397,9 @@ var Resolver = class {
     const doc = await this.getDocument(realPath);
     const oldDoc = this.resolveLegacyValues(doc?._rawData || {}, collection);
     if (isAddPendingDocument === true) {
+      console.warn(
+        "*** DEPRECATION: isAddPendingDocument functionality will be removed Resolver.updateResolveDocument in a future version. ***"
+      );
       const templateInfo = this.tinaSchema.getTemplatesForCollectable(collection);
       const params2 = this.buildParams(args);
       switch (templateInfo.type) {
@@ -5187,41 +5456,8 @@ var Resolver = class {
     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
+   * @deprecated
    */
-  resolveLegacyValues = (oldDoc, collection) => {
-    const legacyValues = {};
-    Object.entries(oldDoc).forEach(([key, value]) => {
-      const reservedKeys = [
-        "$_body",
-        "_collection",
-        "_keepTemplateKey",
-        "_template",
-        "_relativePath",
-        "_id"
-      ];
-      if (reservedKeys.includes(key)) {
-        return;
-      }
-      if (oldDoc._template && collection.templates) {
-        const template = collection.templates?.find(
-          ({ name }) => name === oldDoc._template
-        );
-        if (template) {
-          if (!template.fields.find(({ name }) => name === key)) {
-            legacyValues[key] = value;
-          }
-        }
-      }
-      if (oldDoc._collection && collection.fields) {
-        if (!collection.fields.find(({ name }) => name === key)) {
-          legacyValues[key] = value;
-        }
-      }
-    });
-    return legacyValues;
-  };
   resolveDocument = async ({
     args,
     collection: collectionName,
@@ -5233,169 +5469,76 @@ var Resolver = class {
     isCollectionSpecific,
     isUpdateName
   }) => {
-    let collectionLookup = collectionName || void 0;
-    if (!collectionLookup && isCollectionSpecific === false) {
-      collectionLookup = Object.keys(args.params)[0];
-    }
-    const collectionNames = this.tinaSchema.getCollections().map((item) => item.name);
-    assertShape(
-      collectionLookup,
-      (yup3) => {
-        return yup3.mixed().oneOf(collectionNames);
-      },
-      `"collection" must be one of: [${collectionNames.join(
-        ", "
-      )}] but got ${collectionLookup}`
-    );
+    const { collection } = this.resolveAndValidateCollection({
+      collectionName,
+      args,
+      isCollectionSpecific
+    });
     assertShape(
       args,
       (yup3) => yup3.object({ relativePath: yup3.string().required() })
     );
-    const collection = await this.tinaSchema.getCollection(collectionLookup);
-    let realPath = path3.join(collection?.path, args.relativePath);
-    if (isFolderCreation) {
-      realPath = `${realPath}/.gitkeep.${collection.format || "md"}`;
-    }
-    const alreadyExists = await this.database.documentExists(realPath);
     if (isMutation) {
       if (isCreation) {
-        if (alreadyExists === true) {
-          throw new Error(`Unable to add document, ${realPath} already exists`);
+        if (isAddPendingDocument) {
+          assertShape(
+            args,
+            (yup3) => yup3.object({ template: yup3.string() })
+          );
+          return this.resolveAddPendingDocument({
+            collectionName: collection.name,
+            relativePath: args.relativePath,
+            templateName: args.template || ""
+          });
+        } else {
+          assertShape(
+            args,
+            (yup3) => yup3.object({ params: yup3.object().required() })
+          );
+          return this.resolveCreateDocument({
+            collectionName: collection.name,
+            relativePath: args.relativePath,
+            body: args.params[collection.name]
+          });
         }
-        return this.createResolveDocument({
+      } else if (isFolderCreation) {
+        return this.resolveCreateFolder({
+          collectionName: collection.name,
+          relativePath: args.relativePath
+        });
+      } else if (isDeletion) {
+        return this.resolveDeleteDocument({
+          collectionName: collection.name,
+          relativePath: args.relativePath
+        });
+      } else if (isUpdateName) {
+        assertShape(
+          args,
+          (yup3) => yup3.object({
+            params: yup3.object({ relativePath: yup3.string().required() }).required()
+          })
+        );
+        const realPath = path3.join(collection.path, args.relativePath);
+        return this.updateResolveDocument({
           collection,
           realPath,
           args,
-          isAddPendingDocument
+          isAddPendingDocument,
+          isCollectionSpecific
         });
-      } else if (isFolderCreation) {
-        if (alreadyExists === true) {
-          throw new Error(`Unable to add folder, ${realPath} already exists`);
-        }
-        await this.database.put(
-          realPath,
-          { _is_tina_folder_placeholder: true },
-          collection.name
-        );
-        return this.getDocument(realPath);
-      }
-      if (!alreadyExists) {
-        if (isDeletion) {
-          throw new Error(
-            `Unable to delete document, ${realPath} does not exist`
-          );
-        }
-        if (isUpdateName) {
-          throw new Error(
-            `Unable to update document, ${realPath} does not exist`
-          );
-        }
-      }
-      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) {
+      } else {
         assertShape(
           args,
           (yup3) => yup3.object({ params: yup3.object().required() })
         );
-        assertShape(
-          args?.params,
-          (yup3) => yup3.object({ relativePath: yup3.string().required() })
-        );
-        const doc = await this.getDocument(realPath);
-        const newRealPath = path3.join(
-          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`
-        );
+        return this.resolveUpdateDocument({
+          collectionName: collection.name,
+          relativePath: args.relativePath,
+          newBody: isCollectionSpecific ? args.params : args.params[collection.name]
+        });
       }
-      return this.updateResolveDocument({
-        collection,
-        realPath,
-        args,
-        isAddPendingDocument,
-        isCollectionSpecific
-      });
     } else {
+      const realPath = path3.join(collection.path, args.relativePath);
       return this.getDocument(realPath, {
         collection,
         checkReferences: true
@@ -5435,7 +5578,7 @@ var Resolver = class {
           first: -1
         },
         collection: referencedCollection,
-        hydrator: (path7) => path7
+        hydrator: (path8) => path8
         // just return the path
       }
     );
@@ -5750,6 +5893,7 @@ var resolveDateInput = (value) => {
 };
 
 // src/resolver/auth-fields.ts
+import path4 from "path";
 import { set } from "es-toolkit/compat";
 async function getUserDocumentContext(tinaSchema, resolver) {
   const collection = tinaSchema.getCollections().find((c) => c.isAuthCollection);
@@ -5766,13 +5910,14 @@ async function getUserDocumentContext(tinaSchema, resolver) {
     );
   }
   const userField = userFields[0];
-  const realPath = `${collection.path}/index.json`;
+  const relativePath = "index.json";
+  const realPath = path4.join(collection.path, relativePath);
   const userDoc = await resolver.getDocument(realPath);
   const users = get(userDoc, userField.path);
   if (!users) {
     throw new Error("No users found");
   }
-  return { collection, userField, users, userDoc, realPath };
+  return { collection, userField, users, userDoc, relativePath };
 }
 function findUserInCollection(users, userField, userSub) {
   const { idFieldName } = userField;
@@ -5834,7 +5979,7 @@ async function handleUpdatePassword({
   if (!password) {
     throw new Error("No password provided");
   }
-  const { collection, userField, users, realPath } = await getUserDocumentContext(tinaSchema, resolver);
+  const { collection, userField, users, relativePath } = await getUserDocumentContext(tinaSchema, resolver);
   const { idFieldName, passwordFieldName } = userField;
   const user = users.find((u) => u[idFieldName] === ctxUser.sub);
   if (!user) {
@@ -5844,9 +5989,9 @@ async function handleUpdatePassword({
     value: password,
     passwordChangeRequired: false
   };
-  const params = {};
+  const newBody = {};
   set(
-    params,
+    newBody,
     userField.path.slice(1),
     // remove _rawData from users path
     users.map((u) => {
@@ -5863,12 +6008,10 @@ async function handleUpdatePassword({
       };
     })
   );
-  await resolver.updateResolveDocument({
-    collection,
-    args: { params },
-    realPath,
-    isCollectionSpecific: true,
-    isAddPendingDocument: false
+  await resolver.resolveUpdateDocument({
+    collectionName: collection.name,
+    relativePath,
+    newBody
   });
   return true;
 }
@@ -5876,8 +6019,8 @@ async function handleUpdatePassword({
 // src/error.ts
 import { GraphQLError as GraphQLError3 } from "graphql";
 var NotFoundError = class extends GraphQLError3 {
-  constructor(message, nodes, source, positions, path7, originalError, extensions) {
-    super(message, nodes, source, positions, path7, originalError, extensions);
+  constructor(message, nodes, source, positions, path8, originalError, extensions) {
+    super(message, nodes, source, positions, path8, originalError, extensions);
     this.name = "NotFoundError";
   }
 };
@@ -5902,10 +6045,8 @@ 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
+      // @ts-expect-error
       flags: tinaConfig?.meta?.flags
     });
     const resolver = createResolver({
@@ -5930,91 +6071,61 @@ var resolve = async ({
         }
         throw new Error(`Unable to find lookup key for ${namedType}`);
       },
-      fieldResolver: async (source = {}, _args = {}, _context, info) => {
+      fieldResolver: async (source = {}, args = {}, _context, info) => {
         try {
-          const args = JSON.parse(JSON.stringify(_args));
           const returnType = getNamedType(info.returnType).toString();
-          const lookup = await database.getLookup(returnType);
-          const isMutation = info.parentType.toString() === "Mutation";
-          const value = source[info.fieldName];
           if (returnType === "Collection") {
-            if (value) {
-              return value;
+            const possibleCollectionValue = source[info.fieldName];
+            if (possibleCollectionValue) {
+              return possibleCollectionValue;
             }
             if (info.fieldName === "collections") {
-              const collectionNode2 = info.fieldNodes.find(
-                (x) => x.name.value === "collections"
-              );
-              const hasDocuments2 = collectionNode2.selectionSet.selections.find(
-                (x) => {
-                  return x?.name?.value === "documents";
-                }
-              );
-              return tinaSchema.getCollections().map((collection) => {
-                return resolver.resolveCollection(
-                  args,
-                  collection.name,
-                  Boolean(hasDocuments2)
-                );
-              });
+              return handleCollectionsField(info, tinaSchema, resolver, args);
             }
-            const collectionNode = info.fieldNodes.find(
-              (x) => x.name.value === "collection"
-            );
-            const hasDocuments = collectionNode.selectionSet.selections.find(
-              (x) => {
-                return x?.name?.value === "documents";
-              }
-            );
-            return resolver.resolveCollection(
-              args,
-              args.collection,
-              Boolean(hasDocuments)
-            );
+            return handleCollectionField(info, args, resolver);
           }
           if (info.fieldName === "getOptimizedQuery") {
-            try {
-              return args.queryString;
-            } catch (e) {
-              throw new Error(
-                `Invalid query provided, Error message: ${e.message}`
-              );
-            }
+            return args.queryString || "";
           }
           if (info.fieldName === "authenticate") {
+            const authArgs = args;
             return handleAuthenticate({
               tinaSchema,
               resolver,
-              sub: args.sub,
-              password: args.password,
+              sub: authArgs.sub,
+              password: authArgs.password,
               info,
               ctxUser
             });
           }
           if (info.fieldName === "authorize") {
+            const authArgs = args;
             return handleAuthorize({
               tinaSchema,
               resolver,
-              sub: args.sub,
+              sub: authArgs.sub,
               info,
               ctxUser
             });
           }
           if (info.fieldName === "updatePassword") {
+            const authArgs = args;
             return handleUpdatePassword({
               tinaSchema,
               resolver,
-              password: args.password,
+              password: authArgs.password,
               info,
               ctxUser
             });
           }
+          const lookup = await database.getLookup(returnType);
           if (!lookup) {
-            return value;
+            return source[info.fieldName];
           }
           const isCreation = lookup[info.fieldName] === "create";
+          const isMutation = info.parentType.toString() === "Mutation";
           switch (lookup.resolveType) {
-            /**
+            /*
              * `node(id: $id)`
              */
             case "nodeDocument":
@@ -6024,78 +6135,114 @@ var resolve = async ({
               );
               return resolver.getDocument(args.id);
             case "multiCollectionDocument":
-              if (typeof value === "string" && value !== "") {
-                return resolver.getDocument(value);
-              }
-              if (args?.collection && info.fieldName === "addPendingDocument") {
-                return resolver.resolveDocument({
-                  args: { ...args, params: {} },
-                  collection: args.collection,
-                  isMutation,
-                  isCreation: true,
-                  isAddPendingDocument: true
-                });
+              const possibleValue = source[info.fieldName];
+              if (typeof possibleValue === "string" && possibleValue !== "") {
+                return resolver.getDocument(possibleValue);
               }
               if ([
                 NAMER.documentQueryName(),
+                "addPendingDocument",
                 "createDocument",
                 "updateDocument",
                 "deleteDocument",
                 "createFolder"
               ].includes(info.fieldName)) {
-                const result = await resolver.resolveDocument({
+                assertShape(
                   args,
-                  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),
-                  isAddPendingDocument: false,
-                  isCollectionSpecific: false
-                });
-                return result;
+                  (yup3) => yup3.object({
+                    collection: yup3.string().required(),
+                    relativePath: yup3.string().required()
+                  })
+                );
+                if (isMutation) {
+                  switch (info.fieldName) {
+                    case "addPendingDocument":
+                      return resolver.resolveAddPendingDocument({
+                        collectionName: args.collection,
+                        relativePath: args.relativePath,
+                        templateName: args.template
+                      });
+                    case "createFolder":
+                      return resolver.resolveCreateFolder({
+                        collectionName: args.collection,
+                        relativePath: args.relativePath
+                      });
+                    case "createDocument": {
+                      assertShape(
+                        args,
+                        (yup3) => yup3.object({
+                          params: yup3.object().shape({
+                            [args.collection]: yup3.object().required()
+                          }).required()
+                        })
+                      );
+                      return resolver.resolveCreateDocument({
+                        collectionName: args.collection,
+                        relativePath: args.relativePath,
+                        body: args.params[args.collection]
+                      });
+                    }
+                    case "updateDocument": {
+                      assertShape(
+                        args,
+                        (yup3) => yup3.object({
+                          params: yup3.object().shape({
+                            relativePath: yup3.string().optional()
+                          }).required()
+                        })
+                      );
+                      const newRelativePath = args.params.relativePath;
+                      const newBody = args.params[args.collection];
+                      return resolver.resolveUpdateDocument({
+                        collectionName: args.collection,
+                        relativePath: args.relativePath,
+                        newRelativePath,
+                        newBody
+                      });
+                    }
+                    case "deleteDocument":
+                      return resolver.resolveDeleteDocument({
+                        collectionName: args.collection,
+                        relativePath: args.relativePath
+                      });
+                  }
+                } else if (info.fieldName === NAMER.documentQueryName()) {
+                  return resolver.resolveRetrievedDocument({
+                    collectionName: args.collection,
+                    relativePath: args.relativePath
+                  });
+                }
               }
-              return value;
-            /**
+              return possibleValue;
+            /*
              * eg `getMovieDocument.data.actors`
              */
             case "multiCollectionDocumentList":
-              if (Array.isArray(value)) {
+              const listValue = source[info.fieldName];
+              if (Array.isArray(listValue)) {
                 return {
-                  totalCount: value.length,
-                  edges: value.map((document) => {
+                  totalCount: listValue.length,
+                  edges: listValue.map((document) => {
                     return { node: document };
                   })
                 };
               }
-              if (info.fieldName === "documents" && value?.collection && value?.hasDocuments) {
-                let filter = args.filter;
-                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];
-                }
+              if (info.fieldName === "documents" && listValue?.collection && listValue?.hasDocuments) {
+                const documentsArgs = args;
+                const collectionName = listValue.collection?.name;
+                const filter = (collectionName && documentsArgs.filter?.[collectionName]) ?? documentsArgs.filter;
                 return resolver.resolveCollectionConnection({
                   args: {
-                    ...args,
+                    ...documentsArgs,
                     filter
                   },
-                  // @ts-ignore
-                  collection: value.collection
+                  collection: listValue.collection
                 });
               }
               throw new Error(
                 `Expected an array for result of ${info.fieldName} at ${info.path}`
               );
-            /**
+            /*
              * Collections-specific getter
              * eg. `getPostDocument`/`createPostDocument`/`updatePostDocument`
              *
@@ -6103,29 +6250,54 @@ var resolve = async ({
              * the field will be `node`
              */
             case "collectionDocument": {
-              if (value) {
-                return value;
+              const possibleDocValue = source[info.fieldName];
+              if (possibleDocValue) {
+                return possibleDocValue;
               }
-              const result = value || await resolver.resolveDocument({
+              assertShape(
                 args,
-                collection: lookup.collection,
-                isMutation,
-                isCreation,
-                isAddPendingDocument: false,
-                isCollectionSpecific: true
-              });
-              return result;
+                (yup3) => yup3.object({
+                  relativePath: yup3.string().required()
+                })
+              );
+              if (isMutation) {
+                assertShape(
+                  args,
+                  (yup3) => yup3.object({
+                    params: yup3.object().required()
+                  })
+                );
+                if (isCreation) {
+                  return resolver.resolveCreateDocument({
+                    collectionName: lookup.collection,
+                    relativePath: args.relativePath,
+                    body: args.params
+                  });
+                } else {
+                  return resolver.resolveUpdateDocument({
+                    collectionName: lookup.collection,
+                    relativePath: args.relativePath,
+                    newBody: args.params
+                  });
+                }
+              } else {
+                return resolver.resolveRetrievedDocument({
+                  collectionName: lookup.collection,
+                  relativePath: args.relativePath
+                });
+              }
             }
-            /**
+            /*
              * Collections-specific list getter
              * eg. `getPageList`
              */
             case "collectionDocumentList":
+              const collectionArgs = args;
               return resolver.resolveCollectionConnection({
-                args,
+                args: collectionArgs,
                 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
              *
@@ -6143,22 +6315,52 @@ var resolve = async ({
              * ```
              */
             case "unionData":
-              if (!value) {
-                if (args.relativePath) {
-                  const result = await resolver.resolveDocument({
+              const unionValue = source[info.fieldName];
+              if (!unionValue) {
+                const unionArgs = args;
+                if (unionArgs.relativePath) {
+                  assertShape(
                     args,
-                    collection: lookup.collection,
-                    isMutation,
-                    isCreation,
-                    isAddPendingDocument: false,
-                    isCollectionSpecific: true
-                  });
-                  return result;
+                    (yup3) => yup3.object({
+                      relativePath: yup3.string().required()
+                    })
+                  );
+                  if (isMutation) {
+                    assertShape(
+                      args,
+                      (yup3) => yup3.object({
+                        params: yup3.object().required()
+                      })
+                    );
+                    if (isCreation) {
+                      return resolver.resolveCreateDocument({
+                        collectionName: lookup.collection,
+                        relativePath: args.relativePath,
+                        body: args.params
+                      });
+                    } else {
+                      return resolver.resolveUpdateDocument({
+                        collectionName: lookup.collection,
+                        relativePath: args.relativePath,
+                        newBody: args.params
+                      });
+                    }
+                  } else {
+                    return resolver.resolveRetrievedDocument({
+                      collectionName: lookup.collection,
+                      relativePath: args.relativePath
+                    });
+                  }
                 }
               }
-              return value;
+              return unionValue;
             default:
-              console.error(lookup);
+              console.error(
+                `Could not recognize resolve type '${lookup.resolveType}'.`
+              );
+              console.error(
+                "The field resolver needs to be updated to handle this new type."
+              );
               throw new Error("Unexpected resolve type");
           }
         } catch (e) {
@@ -6194,6 +6396,40 @@ var resolve = async ({
     throw e;
   }
 };
+var handleCollectionsField = (info, tinaSchema, resolver, args) => {
+  const collectionNode = info.fieldNodes.find(
+    (x) => x.name.value === "collections"
+  );
+  const hasDocuments = collectionNode.selectionSet.selections.find(
+    (x) => x.kind == "Field" && x?.name?.value === "documents"
+  );
+  return tinaSchema.getCollections().map((collection) => {
+    return resolver.resolveCollection(
+      args,
+      collection.name,
+      Boolean(hasDocuments)
+    );
+  });
+};
+var handleCollectionField = (info, args, resolver) => {
+  const collectionNode = info.fieldNodes.find(
+    (x) => x.name.value === "collection"
+  );
+  const hasDocuments = collectionNode.selectionSet.selections.find(
+    (x) => x.kind == "Field" && x?.name?.value === "documents"
+  );
+  assertShape(
+    args,
+    (yup3) => yup3.object({
+      collection: yup3.string().required()
+    })
+  );
+  return resolver.resolveCollection(
+    args,
+    args.collection,
+    Boolean(hasDocuments)
+  );
+};
 
 // src/level/tinaLevel.ts
 import { ManyLevelGuest } from "many-level";
@@ -6217,7 +6453,7 @@ var TinaLevelClient = class extends ManyLevelGuest {
 };
 
 // src/database/index.ts
-import path4 from "node:path";
+import path5 from "node:path";
 import { GraphQLError as GraphQLError5 } from "graphql";
 import micromatch2 from "micromatch";
 import sha2 from "js-sha1";
@@ -6308,7 +6544,7 @@ var Database = class {
     } catch (e) {
     }
   };
-  getGeneratedFolder = () => path4.join(this.tinaDirectory, "__generated__");
+  getGeneratedFolder = () => path5.join(this.tinaDirectory, "__generated__");
   async updateDatabaseVersion(version) {
     let metadataLevel = this.rootLevel.sublevel("_metadata", SUBLEVEL_OPTIONS);
     if (this.contentNamespace) {
@@ -6724,7 +6960,7 @@ var Database = class {
     );
     const writeTemplateKey = templateDetails.info.type === "union";
     const aliasedData = applyNameOverrides(templateDetails.template, payload);
-    const extension = path4.extname(filepath);
+    const extension = path5.extname(filepath);
     return stringifyFile(
       aliasedData,
       extension,
@@ -6756,7 +6992,7 @@ var Database = class {
   getLookup = async (returnType) => {
     await this.initLevel();
     const lookupPath = normalizePath(
-      path4.join(this.getGeneratedFolder(), `_lookup.json`)
+      path5.join(this.getGeneratedFolder(), `_lookup.json`)
     );
     if (!this._lookup) {
       this._lookup = await this.contentLevel.sublevel(
@@ -6769,7 +7005,7 @@ var Database = class {
   getGraphQLSchema = async () => {
     await this.initLevel();
     const graphqlPath = normalizePath(
-      path4.join(this.getGeneratedFolder(), `_graphql.json`)
+      path5.join(this.getGeneratedFolder(), `_graphql.json`)
     );
     return await this.contentLevel.sublevel(
       CONTENT_ROOT_PREFIX,
@@ -6782,7 +7018,7 @@ var Database = class {
       throw new Error(`No bridge configured`);
     }
     const graphqlPath = normalizePath(
-      path4.join(this.getGeneratedFolder(), `_graphql.json`)
+      path5.join(this.getGeneratedFolder(), `_graphql.json`)
     );
     const _graphql = await this.bridge.get(graphqlPath);
     return JSON.parse(_graphql);
@@ -6790,7 +7026,7 @@ var Database = class {
   getTinaSchema = async (level) => {
     await this.initLevel();
     const schemaPath = normalizePath(
-      path4.join(this.getGeneratedFolder(), `_schema.json`)
+      path5.join(this.getGeneratedFolder(), `_schema.json`)
     );
     return await (level || this.contentLevel).sublevel(
       CONTENT_ROOT_PREFIX,
@@ -6806,7 +7042,7 @@ var Database = class {
     if (!schema) {
       throw new Error(
         `Unable to get schema from level db: ${normalizePath(
-          path4.join(this.getGeneratedFolder(), `_schema.json`)
+          path5.join(this.getGeneratedFolder(), `_schema.json`)
         )}`
       );
     }
@@ -7039,21 +7275,21 @@ var Database = class {
         edges,
         async ({
           cursor,
-          path: path7,
+          path: path8,
           value
         }) => {
           try {
-            const node = await hydrator(path7, value);
+            const node = await hydrator(path8, 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"))) {
+            if (error instanceof Error && (!path8.includes(".tina/__generated__/_graphql.json") || !path8.includes("tina/__generated__/_graphql.json"))) {
               throw new TinaQueryError({
                 originalError: error,
-                file: path7,
+                file: path8,
                 collection: collection.name
               });
             }
@@ -7100,7 +7336,7 @@ var Database = class {
           lookup = lookupFromLockFile || JSON.parse(
             await this.bridge.get(
               normalizePath(
-                path4.join(this.getGeneratedFolder(), "_lookup.json")
+                path5.join(this.getGeneratedFolder(), "_lookup.json")
               )
             )
           );
@@ -7124,15 +7360,15 @@ var Database = class {
         }
         const contentRootLevel = nextLevel.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS);
         await contentRootLevel.put(
-          normalizePath(path4.join(this.getGeneratedFolder(), "_graphql.json")),
+          normalizePath(path5.join(this.getGeneratedFolder(), "_graphql.json")),
           graphQLSchema
         );
         await contentRootLevel.put(
-          normalizePath(path4.join(this.getGeneratedFolder(), "_schema.json")),
+          normalizePath(path5.join(this.getGeneratedFolder(), "_schema.json")),
           tinaSchema.schema
         );
         await contentRootLevel.put(
-          normalizePath(path4.join(this.getGeneratedFolder(), "_lookup.json")),
+          normalizePath(path5.join(this.getGeneratedFolder(), "_lookup.json")),
           lookup
         );
         const result = await this._indexAllContent(
@@ -7341,8 +7577,8 @@ var Database = class {
     return { warnings };
   };
 };
-var hashPasswordVisitor = async (node, path7) => {
-  const passwordValuePath = [...path7, "value"];
+var hashPasswordVisitor = async (node, path8) => {
+  const passwordValuePath = [...path8, "value"];
   const plaintextPassword = get(node, passwordValuePath);
   if (plaintextPassword) {
     set2(
@@ -7352,10 +7588,10 @@ var hashPasswordVisitor = async (node, path7) => {
     );
   }
 };
-var visitNodes = async (node, path7, callback) => {
-  const [currentLevel, ...remainingLevels] = path7;
+var visitNodes = async (node, path8, callback) => {
+  const [currentLevel, ...remainingLevels] = path8;
   if (!remainingLevels?.length) {
-    return callback(node, path7);
+    return callback(node, path8);
   }
   if (Array.isArray(node[currentLevel])) {
     for (const item of node[currentLevel]) {
@@ -7598,13 +7834,13 @@ var _deleteIndexContent = async (database, documentPaths, enqueueOps, collection
 // src/git/index.ts
 import git from "isomorphic-git";
 import fs from "fs-extra";
-import path5 from "path";
+import path6 from "path";
 import micromatch3 from "micromatch";
 var findGitRoot = async (dir) => {
-  if (await fs.pathExists(path5.join(dir, ".git"))) {
+  if (await fs.pathExists(path6.join(dir, ".git"))) {
     return dir;
   }
-  const parentDir = path5.dirname(dir);
+  const parentDir = path6.dirname(dir);
   if (parentDir === dir) {
     throw new Error("Could not find .git directory");
   }
@@ -7686,19 +7922,19 @@ var shaExists = async ({
 // src/database/bridge/filesystem.ts
 import fs2 from "fs-extra";
 import fg from "fast-glob";
-import path6 from "path";
+import path7 from "path";
 import normalize from "normalize-path";
 var FilesystemBridge = class {
   rootPath;
   outputPath;
   constructor(rootPath, outputPath) {
-    this.rootPath = path6.resolve(rootPath);
-    this.outputPath = outputPath ? path6.resolve(outputPath) : this.rootPath;
+    this.rootPath = path7.resolve(rootPath);
+    this.outputPath = outputPath ? path7.resolve(outputPath) : this.rootPath;
   }
   async glob(pattern, extension) {
-    const basePath = path6.join(this.outputPath, ...pattern.split("/"));
+    const basePath = path7.join(this.outputPath, ...pattern.split("/"));
     const items = await fg(
-      path6.join(basePath, "**", `/*.${extension}`).replace(/\\/g, "/"),
+      path7.join(basePath, "**", `/*.${extension}`).replace(/\\/g, "/"),
       {
         dot: true,
         ignore: ["**/node_modules/**"]
@@ -7710,14 +7946,14 @@ var FilesystemBridge = class {
     );
   }
   async delete(filepath) {
-    await fs2.remove(path6.join(this.outputPath, filepath));
+    await fs2.remove(path7.join(this.outputPath, filepath));
   }
   async get(filepath) {
-    return (await fs2.readFile(path6.join(this.outputPath, filepath))).toString();
+    return (await fs2.readFile(path7.join(this.outputPath, filepath))).toString();
   }
   async put(filepath, data, basePathOverride) {
     const basePath = basePathOverride || this.outputPath;
-    await fs2.outputFile(path6.join(basePath, filepath), data);
+    await fs2.outputFile(path7.join(basePath, filepath), data);
   }
 };
 var AuditFileSystemBridge = class extends FilesystemBridge {
@@ -7821,7 +8057,7 @@ var IsomorphicBridge = class {
   async listEntries({
     pattern,
     entry,
-    path: path7,
+    path: path8,
     results
   }) {
     const treeResult = await git2.readTree({
@@ -7831,7 +8067,7 @@ var IsomorphicBridge = class {
     });
     const children = [];
     for (const childEntry of treeResult.tree) {
-      const childPath = path7 ? `${path7}/${childEntry.path}` : childEntry.path;
+      const childPath = path8 ? `${path8}/${childEntry.path}` : childEntry.path;
       if (childEntry.type === "tree") {
         children.push(childEntry);
       } else {
@@ -7841,7 +8077,7 @@ var IsomorphicBridge = class {
       }
     }
     for (const childEntry of children) {
-      const childPath = path7 ? `${path7}/${childEntry.path}` : childEntry.path;
+      const childPath = path8 ? `${path8}/${childEntry.path}` : childEntry.path;
       await this.listEntries({
         pattern,
         entry: childEntry,
@@ -7859,17 +8095,17 @@ var IsomorphicBridge = class {
    * @param ref - ref to resolve path entries for
    * @private
    */
-  async resolvePathEntries(path7, ref) {
-    let pathParts = path7.split("/");
+  async resolvePathEntries(path8, ref) {
+    let pathParts = path8.split("/");
     const result = await git2.walk({
       ...this.isomorphicConfig,
       map: async (filepath, [head]) => {
         if (head._fullpath === ".") {
           return head;
         }
-        if (path7.startsWith(filepath)) {
-          if (dirname(path7) === dirname(filepath)) {
-            if (path7 === filepath) {
+        if (path8.startsWith(filepath)) {
+          if (dirname(path8) === dirname(filepath)) {
+            if (path8 === filepath) {
               return head;
             }
           } else {
@@ -7900,7 +8136,7 @@ var IsomorphicBridge = class {
    * @param pathParts - parent path parts
    * @private
    */
-  async updateTreeHierarchy(existingOid, updatedOid, path7, type, pathEntries, pathParts) {
+  async updateTreeHierarchy(existingOid, updatedOid, path8, type, pathEntries, pathParts) {
     const lastIdx = pathEntries.length - 1;
     const parentEntry = pathEntries[lastIdx];
     const parentPath = pathParts[lastIdx];
@@ -7915,7 +8151,7 @@ var IsomorphicBridge = class {
         cache: this.cache
       });
       tree = existingOid ? treeResult.tree.map((entry) => {
-        if (entry.path === path7) {
+        if (entry.path === path8) {
           entry.oid = updatedOid;
         }
         return entry;
@@ -7924,7 +8160,7 @@ var IsomorphicBridge = class {
         {
           oid: updatedOid,
           type,
-          path: path7,
+          path: path8,
           mode
         }
       ];
@@ -7933,7 +8169,7 @@ var IsomorphicBridge = class {
         {
           oid: updatedOid,
           type,
-          path: path7,
+          path: path8,
           mode
         }
       ];
@@ -8042,7 +8278,7 @@ var IsomorphicBridge = class {
       path: parentPath,
       results
     });
-    return results.map((path7) => this.unqualifyPath(path7)).filter((path7) => path7.endsWith(extension));
+    return results.map((path8) => this.unqualifyPath(path8)).filter((path8) => path8.endsWith(extension));
   }
   async delete(filepath) {
     const ref = await this.getRef();