@tinacms/graphql 1.4.14 → 1.4.16

package/dist/index.es.js

@@ -2525,7 +2525,7 @@ var validateField = async (field) => {
 // package.json
 var package_default = {
   name: "@tinacms/graphql",
-  version: "1.4.14",
+  version: "1.4.16",
   main: "dist/index.js",
   module: "dist/index.es.js",
   typings: "dist/index.d.ts",
@@ -2834,7 +2834,7 @@ import {
 } from "graphql";
 
 // src/resolver/index.ts
-import path2 from "path";
+import path3 from "path";
 import isValid from "date-fns/isValid";
 
 // src/mdx/index.ts
@@ -3066,9 +3066,9 @@ var resolveMediaRelativeToCloud = (value, config = { useRelativeMedia: true }, s
     return value;
   }
 };
-var cleanUpSlashes = (path5) => {
-  if (path5) {
-    return `/${path5.replace(/^\/+|\/+$/gm, "")}`;
+var cleanUpSlashes = (path6) => {
+  if (path6) {
+    return `/${path6.replace(/^\/+|\/+$/gm, "")}`;
   }
   return "";
 };
@@ -3134,13 +3134,131 @@ var LevelProxy = class {
 };
 
 // src/database/datalayer.ts
-import path from "path";
+import path2 from "path";
 
 // src/database/util.ts
 import toml from "@iarna/toml";
 import yaml from "js-yaml";
 import matter from "gray-matter";
-import { normalizePath } from "@tinacms/schema-tools";
+import {
+  normalizePath
+} from "@tinacms/schema-tools";
+import micromatch from "micromatch";
+import path from "path";
+
+// src/database/alias-utils.ts
+var replaceBlockAliases = (template, item) => {
+  const output = { ...item };
+  const templateKey = template.templateKey || "_template";
+  const templateName = output[templateKey];
+  const matchingTemplate = template.templates.find(
+    (t) => t.nameOverride == templateName || t.name == templateName
+  );
+  if (!matchingTemplate) {
+    throw new Error(
+      `Block template "${templateName}" is not defined for field "${template.name}"`
+    );
+  }
+  output._template = matchingTemplate.name;
+  if (templateKey != "_template") {
+    delete output[templateKey];
+  }
+  return output;
+};
+var replaceNameOverrides = (template, obj) => {
+  if (template.list) {
+    return obj.map((item) => {
+      if (isBlockField(template)) {
+        item = replaceBlockAliases(template, item);
+      }
+      return _replaceNameOverrides(
+        getTemplateForData(template, item).fields,
+        item
+      );
+    });
+  } else {
+    return _replaceNameOverrides(getTemplateForData(template, obj).fields, obj);
+  }
+};
+function isBlockField(field) {
+  return field && field.type === "object" && field.templates?.length > 0;
+}
+var _replaceNameOverrides = (fields, obj) => {
+  const output = {};
+  Object.keys(obj).forEach((key) => {
+    const field = fields.find(
+      (fieldWithMatchingAlias) => (fieldWithMatchingAlias?.nameOverride || fieldWithMatchingAlias?.name) === key
+    );
+    output[field?.name || key] = field?.type == "object" ? replaceNameOverrides(field, obj[key]) : obj[key];
+  });
+  return output;
+};
+var getTemplateForData = (field, data) => {
+  if (field.templates?.length) {
+    const templateKey = "_template";
+    if (data[templateKey]) {
+      const result = field.templates.find(
+        (template) => template.nameOverride === data[templateKey] || template.name === data[templateKey]
+      );
+      if (result) {
+        return result;
+      }
+      throw new Error(
+        `Template "${data[templateKey]}" is not defined for field "${field.name}"`
+      );
+    }
+    throw new Error(
+      `Missing required key "${templateKey}" on field "${field.name}"`
+    );
+  } else {
+    return field;
+  }
+};
+var applyBlockAliases = (template, item) => {
+  const output = { ...item };
+  const templateKey = template.templateKey || "_template";
+  const templateName = output._template;
+  const matchingTemplate = template.templates.find(
+    (t) => t.nameOverride == templateName || t.name == templateName
+  );
+  if (!matchingTemplate) {
+    throw new Error(
+      `Block template "${templateName}" is not defined for field "${template.name}"`
+    );
+  }
+  output[templateKey] = matchingTemplate.nameOverride || matchingTemplate.name;
+  if (templateKey != "_template") {
+    delete output._template;
+  }
+  return output;
+};
+var applyNameOverrides = (template, obj) => {
+  if (template.list) {
+    return obj.map((item) => {
+      let result = _applyNameOverrides(
+        getTemplateForData(template, item).fields,
+        item
+      );
+      if (isBlockField(template)) {
+        result = applyBlockAliases(template, result);
+      }
+      return result;
+    });
+  } else {
+    return _applyNameOverrides(getTemplateForData(template, obj).fields, obj);
+  }
+};
+var _applyNameOverrides = (fields, obj) => {
+  const output = {};
+  Object.keys(obj).forEach((key) => {
+    const field = fields.find((field2) => field2.name === key);
+    const outputKey = field?.nameOverride || key;
+    output[outputKey] = field?.type === "object" ? applyNameOverrides(field, obj[key]) : obj[key];
+  });
+  return output;
+};
+
+// src/database/util.ts
 var matterEngines = {
   toml: {
     parse: (val) => toml.parse(val),
@@ -3224,6 +3342,142 @@ var parseFile = (content, format, yupSchema, markdownParseConfig) => {
       throw new Error(`Must specify a valid format, got ${format}`);
   }
 };
+var scanAllContent = async (tinaSchema, bridge, callback) => {
+  const warnings = [];
+  const filesSeen = /* @__PURE__ */ new Map();
+  const duplicateFiles = /* @__PURE__ */ new Set();
+  await sequential(tinaSchema.getCollections(), async (collection) => {
+    const normalPath = normalizePath(collection.path);
+    const format = collection.format || "md";
+    const documentPaths = await bridge.glob(normalPath, format);
+    const matches = tinaSchema.getMatches({ collection });
+    const filteredPaths = matches.length > 0 ? micromatch(documentPaths, matches) : documentPaths;
+    filteredPaths.forEach((path6) => {
+      if (filesSeen.has(path6)) {
+        filesSeen.get(path6).push(collection.name);
+        duplicateFiles.add(path6);
+      } else {
+        filesSeen.set(path6, [collection.name]);
+      }
+    });
+    duplicateFiles.forEach((path6) => {
+      warnings.push(
+        `"${path6}" Found in multiple collections: ${filesSeen.get(path6).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/
+`
+      );
+    });
+    await callback(collection, filteredPaths);
+  });
+  return warnings;
+};
+var scanContentByPaths = async (tinaSchema, documentPaths, callback) => {
+  const { pathsByCollection, nonCollectionPaths, collections } = await partitionPathsByCollection(tinaSchema, documentPaths);
+  for (const collection of Object.keys(pathsByCollection)) {
+    await callback(collections[collection], pathsByCollection[collection]);
+  }
+  if (nonCollectionPaths.length) {
+    await callback(void 0, nonCollectionPaths);
+  }
+};
+var partitionPathsByCollection = async (tinaSchema, documentPaths) => {
+  const pathsByCollection = {};
+  const nonCollectionPaths = [];
+  const collections = {};
+  for (const documentPath of documentPaths) {
+    const collection = await tinaSchema.getCollectionByFullPath(documentPath);
+    if (collection) {
+      if (!pathsByCollection[collection.name]) {
+        pathsByCollection[collection.name] = [];
+      }
+      collections[collection.name] = collection;
+      pathsByCollection[collection.name].push(documentPath);
+    } else {
+      nonCollectionPaths.push(documentPath);
+    }
+  }
+  return { pathsByCollection, nonCollectionPaths, collections };
+};
+var transformDocument = (filepath, contentObject, tinaSchema) => {
+  const extension = path.extname(filepath);
+  const templateName = hasOwnProperty(contentObject, "_template") && typeof contentObject._template === "string" ? contentObject._template : void 0;
+  const { collection, template } = hasOwnProperty(contentObject, "__collection") ? {
+    collection: tinaSchema.getCollection(
+      contentObject["__collection"]
+    ),
+    template: void 0
+  } : tinaSchema.getCollectionAndTemplateByFullPath(filepath, templateName);
+  const field = template?.fields.find((field2) => {
+    if (field2.type === "string" || field2.type === "rich-text") {
+      if (field2.isBody) {
+        return true;
+      }
+    }
+    return false;
+  });
+  let data = contentObject;
+  if ((extension === ".md" || extension === ".mdx") && field) {
+    if (hasOwnProperty(contentObject, "$_body")) {
+      const { $_body, ...rest } = contentObject;
+      data = rest;
+      data[field.name] = $_body;
+    }
+  }
+  return {
+    ...data,
+    _collection: collection.name,
+    _keepTemplateKey: !!collection.templates,
+    _template: template?.namespace ? lastItem(template?.namespace) : void 0,
+    _relativePath: filepath.replace(collection.path, "").replace(/^\/|\/$/g, ""),
+    _id: filepath
+  };
+};
+function hasOwnProperty(obj, prop) {
+  return obj.hasOwnProperty(prop);
+}
+var getTemplateForFile = (templateInfo, data) => {
+  if (templateInfo?.type === "object") {
+    return templateInfo.template;
+  }
+  if (templateInfo?.type === "union") {
+    if (hasOwnProperty(data, "_template")) {
+      const template = templateInfo.templates.find(
+        (t) => lastItem(t.namespace) === data._template
+      );
+      if (!template) {
+        throw new Error(
+          `Unable to find template "${data._template}". Possible templates are: ${templateInfo.templates.map((template2) => `"${template2.name}"`).join(", ")}.`
+        );
+      }
+      return template;
+    } else {
+      return void 0;
+    }
+  }
+  throw new Error(`Unable to determine template`);
+};
+var loadAndParseWithAliases = async (bridge, filepath, collection, templateInfo) => {
+  const dataString = await bridge.get(normalizePath(filepath));
+  const data = parseFile(
+    dataString,
+    path.extname(filepath),
+    (yup3) => yup3.object({}),
+    {
+      frontmatterDelimiters: collection?.frontmatterDelimiters,
+      frontmatterFormat: collection?.frontmatterFormat
+    }
+  );
+  const template = getTemplateForFile(templateInfo, data);
+  if (!template) {
+    console.warn(
+      `Document: ${filepath} has an ambiguous template, skipping from indexing`
+    );
+    return;
+  }
+  return templateInfo ? replaceNameOverrides(template, data) : data;
+};
 
 // src/database/datalayer.ts
 var DEFAULT_COLLECTION_SORT_KEY = "__filepath__";
@@ -3668,9 +3922,9 @@ var makeFilterSuffixes = (filterChain, index) => {
   }
 };
 var FOLDER_ROOT = "~";
-var stripCollectionFromPath = (collectionPath, path5) => {
+var stripCollectionFromPath = (collectionPath, path6) => {
   const collectionPathParts = collectionPath.split("/");
-  const pathParts = path5.split("/");
+  const pathParts = path6.split("/");
   const strippedPathParts = pathParts.slice(collectionPathParts.length);
   return strippedPathParts.join("/");
 };
@@ -3684,7 +3938,7 @@ var FolderTreeBuilder = class {
     return this._tree;
   }
   update(documentPath, collectionPath) {
-    let folderPath = path.dirname(normalizePath(documentPath));
+    let folderPath = path2.dirname(normalizePath(documentPath));
     if (folderPath === ".") {
       folderPath = "";
     }
@@ -3697,7 +3951,7 @@ var FolderTreeBuilder = class {
       if (!this._tree[current2]) {
         this._tree[current2] = /* @__PURE__ */ new Set();
       }
-      this._tree[current2].add(normalizePath(path.join(current2, part)));
+      this._tree[current2].add(normalizePath(path2.join(current2, part)));
       parent.push(part);
     });
     const current = parent.join("/");
@@ -3725,13 +3979,13 @@ var makeFolderOpsForCollection = (folderTree, collection, indexDefinitions, opTy
       SUBLEVEL_OPTIONS
     );
     let folderSortingIdx = 0;
-    for (const path5 of Array.from(folder).sort()) {
+    for (const path6 of Array.from(folder).sort()) {
       for (const [sort] of Object.entries(indexDefinitions)) {
         const indexSublevel = folderCollectionSublevel.sublevel(
           sort,
           SUBLEVEL_OPTIONS
         );
-        const subFolderKey = sha.hex(path5);
+        const subFolderKey = sha.hex(path6);
         if (sort === DEFAULT_COLLECTION_SORT_KEY) {
           result.push({
             type: opType,
@@ -3759,7 +4013,7 @@ var makeFolderOpsForCollection = (folderTree, collection, indexDefinitions, opTy
         key: `${collection.path}/${parentFolderKey}.${collection.format}`,
         value: {
           __collection: collection.name,
-          __folderBasename: path.basename(folderName),
+          __folderBasename: path2.basename(folderName),
           __folderPath: folderName
         },
         sublevel: level.sublevel(
@@ -3823,6 +4077,194 @@ var stringEscaper = makeStringEscaper(
 var createResolver = (args) => {
   return new Resolver(args);
 };
+var resolveFieldData = async ({ namespace, ...field }, rawData, accumulator, tinaSchema, config, isAudit) => {
+  if (!rawData) {
+    return void 0;
+  }
+  assertShape(rawData, (yup3) => yup3.object());
+  const value = rawData[field.name];
+  switch (field.type) {
+    case "datetime":
+      if (value instanceof Date) {
+        accumulator[field.name] = value.toISOString();
+      } else {
+        accumulator[field.name] = value;
+      }
+      break;
+    case "string":
+    case "boolean":
+    case "number":
+      accumulator[field.name] = value;
+      break;
+    case "reference":
+      if (value) {
+        accumulator[field.name] = value;
+      }
+      break;
+    case "image":
+      accumulator[field.name] = resolveMediaRelativeToCloud(
+        value,
+        config,
+        tinaSchema.schema
+      );
+      break;
+    case "rich-text":
+      const tree = parseMDX(
+        value,
+        field,
+        (value2) => resolveMediaRelativeToCloud(value2, config, tinaSchema.schema)
+      );
+      if (tree?.children[0]?.type === "invalid_markdown") {
+        if (isAudit) {
+          const invalidNode = tree?.children[0];
+          throw new GraphQLError2(
+            `${invalidNode?.message}${invalidNode.position ? ` at line ${invalidNode.position.start.line}, column ${invalidNode.position.start.column}` : ""}`
+          );
+        }
+      }
+      accumulator[field.name] = tree;
+      break;
+    case "object":
+      if (field.list) {
+        if (!value) {
+          return;
+        }
+        assertShape(
+          value,
+          (yup3) => yup3.array().of(yup3.object().required())
+        );
+        accumulator[field.name] = await sequential(value, async (item) => {
+          const template = await tinaSchema.getTemplateForData({
+            data: item,
+            collection: {
+              namespace,
+              ...field
+            }
+          });
+          const payload = {};
+          await sequential(template.fields, async (field2) => {
+            await resolveFieldData(
+              field2,
+              item,
+              payload,
+              tinaSchema,
+              config,
+              isAudit
+            );
+          });
+          const isUnion = !!field.templates;
+          return isUnion ? {
+            _template: lastItem(template.namespace),
+            ...payload
+          } : payload;
+        });
+      } else {
+        if (!value) {
+          return;
+        }
+        const template = await tinaSchema.getTemplateForData({
+          data: value,
+          collection: {
+            namespace,
+            ...field
+          }
+        });
+        const payload = {};
+        await sequential(template.fields, async (field2) => {
+          await resolveFieldData(
+            field2,
+            value,
+            payload,
+            tinaSchema,
+            config,
+            isAudit
+          );
+        });
+        const isUnion = !!field.templates;
+        accumulator[field.name] = isUnion ? {
+          _template: lastItem(template.namespace),
+          ...payload
+        } : payload;
+      }
+      break;
+    default:
+      return field;
+  }
+  return accumulator;
+};
+var transformDocumentIntoPayload = async (fullPath, rawData, tinaSchema, config, isAudit) => {
+  const collection = tinaSchema.getCollection(rawData._collection);
+  try {
+    const template = tinaSchema.getTemplateForData({
+      data: rawData,
+      collection
+    });
+    const {
+      base: basename,
+      ext: extension,
+      name: filename
+    } = path3.parse(fullPath);
+    const relativePath = fullPath.replace(/\\/g, "/").replace(collection.path, "").replace(/^\/|\/$/g, "");
+    const breadcrumbs = relativePath.replace(extension, "").split("/");
+    const data = {
+      _collection: rawData._collection,
+      _template: rawData._template
+    };
+    try {
+      await sequential(template.fields, async (field) => {
+        return resolveFieldData(
+          field,
+          rawData,
+          data,
+          tinaSchema,
+          config,
+          isAudit
+        );
+      });
+    } catch (e) {
+      throw new TinaParseDocumentError({
+        originalError: e,
+        collection: collection.name,
+        includeAuditMessage: !isAudit,
+        file: relativePath,
+        stack: e.stack
+      });
+    }
+    const titleField = template.fields.find((x) => {
+      if (x.type === "string" && x?.isTitle) {
+        return true;
+      }
+    });
+    const titleFieldName = titleField?.name;
+    const title = data[titleFieldName || " "] || null;
+    return {
+      __typename: collection.fields ? NAMER.documentTypeName(collection.namespace) : NAMER.documentTypeName(template.namespace),
+      id: fullPath,
+      ...data,
+      _sys: {
+        title: title || "",
+        basename,
+        filename,
+        extension,
+        path: fullPath,
+        relativePath,
+        breadcrumbs,
+        collection,
+        template: lastItem(template.namespace)
+      },
+      _values: data,
+      _rawData: rawData
+    };
+  } catch (e) {
+    if (e instanceof TinaGraphQLError) {
+      throw new TinaGraphQLError(e.message, {
+        requestedDocument: fullPath,
+        ...e.extensions
+      });
+    }
+    throw e;
+  }
+};
 var Resolver = class {
   constructor(init) {
     this.init = init;
@@ -3855,7 +4297,13 @@ var Resolver = class {
           path: rawData["__folderPath"]
         };
       } else {
-        return this.transformDocumentIntoPayload(fullPath, rawData);
+        return transformDocumentIntoPayload(
+          fullPath,
+          rawData,
+          this.tinaSchema,
+          this.config,
+          this.isAudit
+        );
       }
     };
     this.getDocument = async (fullPath) => {
@@ -3863,73 +4311,13 @@ var Resolver = class {
         throw new Error(`fullPath must be of type string for getDocument request`);
       }
       const rawData = await this.getRaw(fullPath);
-      return this.transformDocumentIntoPayload(fullPath, rawData);
-    };
-    this.transformDocumentIntoPayload = async (fullPath, rawData) => {
-      const collection = this.tinaSchema.getCollection(rawData._collection);
-      try {
-        const template = await this.tinaSchema.getTemplateForData({
-          data: rawData,
-          collection
-        });
-        const {
-          base: basename,
-          ext: extension,
-          name: filename
-        } = path2.parse(fullPath);
-        const relativePath = fullPath.replace(/\\/g, "/").replace(collection.path, "").replace(/^\/|\/$/g, "");
-        const breadcrumbs = relativePath.replace(extension, "").split("/");
-        const data = {
-          _collection: rawData._collection,
-          _template: rawData._template
-        };
-        try {
-          await sequential(template.fields, async (field) => {
-            return this.resolveFieldData(field, rawData, data);
-          });
-        } catch (e) {
-          throw new TinaParseDocumentError({
-            originalError: e,
-            collection: collection.name,
-            includeAuditMessage: !this.isAudit,
-            file: relativePath,
-            stack: e.stack
-          });
-        }
-        const titleField = template.fields.find((x) => {
-          if (x.type === "string" && x?.isTitle) {
-            return true;
-          }
-        });
-        const titleFieldName = titleField?.name;
-        const title = data[titleFieldName || " "] || null;
-        return {
-          __typename: collection.fields ? NAMER.documentTypeName(collection.namespace) : NAMER.documentTypeName(template.namespace),
-          id: fullPath,
-          ...data,
-          _sys: {
-            title: title || "",
-            basename,
-            filename,
-            extension,
-            path: fullPath,
-            relativePath,
-            breadcrumbs,
-            collection,
-            template: lastItem(template.namespace)
-          },
-          _values: data,
-          _rawData: rawData
-        };
-      } catch (e) {
-        if (e instanceof TinaGraphQLError) {
-          throw new TinaGraphQLError(e.message, {
-            requestedDocument: fullPath,
-            ...e.extensions
-          });
-        }
-        throw e;
-      }
+      return transformDocumentIntoPayload(
+        fullPath,
+        rawData,
+        this.tinaSchema,
+        this.config,
+        this.isAudit
+      );
     };
     this.deleteDocument = async (fullPath) => {
       if (typeof fullPath !== "string") {
@@ -4119,7 +4507,7 @@ var Resolver = class {
         (yup3) => yup3.object({ relativePath: yup3.string().required() })
       );
       const collection = await this.tinaSchema.getCollection(collectionLookup);
-      const realPath = path2.join(collection?.path, args.relativePath);
+      const realPath = path3.join(collection?.path, args.relativePath);
       const alreadyExists = await this.database.documentExists(realPath);
       if (isMutation) {
         if (isCreation) {
@@ -4160,7 +4548,7 @@ var Resolver = class {
             (yup3) => yup3.object({ relativePath: yup3.string().required() })
           );
           const doc = await this.getDocument(realPath);
-          const newRealPath = path2.join(
+          const newRealPath = path3.join(
             collection?.path,
             args.params.relativePath
           );
@@ -4215,7 +4603,7 @@ var Resolver = class {
             first: -1
           },
           collection: referencedCollection,
-          hydrator: (path5) => path5
+          hydrator: (path6) => path6
         }
       );
       const { edges } = resolvedCollectionConnection;
@@ -4335,111 +4723,6 @@ var Resolver = class {
       });
       return accum;
     };
-    this.resolveFieldData = async ({ namespace, ...field }, rawData, accumulator) => {
-      if (!rawData) {
-        return void 0;
-      }
-      assertShape(rawData, (yup3) => yup3.object());
-      const value = rawData[field.name];
-      switch (field.type) {
-        case "datetime":
-          if (value instanceof Date) {
-            accumulator[field.name] = value.toISOString();
-          } else {
-            accumulator[field.name] = value;
-          }
-          break;
-        case "string":
-        case "boolean":
-        case "number":
-          accumulator[field.name] = value;
-          break;
-        case "reference":
-          if (value) {
-            accumulator[field.name] = value;
-          }
-          break;
-        case "image":
-          accumulator[field.name] = resolveMediaRelativeToCloud(
-            value,
-            this.config,
-            this.tinaSchema.schema
-          );
-          break;
-        case "rich-text":
-          const tree = parseMDX(
-            value,
-            field,
-            (value2) => resolveMediaRelativeToCloud(
-              value2,
-              this.config,
-              this.tinaSchema.schema
-            )
-          );
-          if (tree?.children[0]?.type === "invalid_markdown") {
-            if (this.isAudit) {
-              const invalidNode = tree?.children[0];
-              throw new GraphQLError2(
-                `${invalidNode?.message}${invalidNode.position ? ` at line ${invalidNode.position.start.line}, column ${invalidNode.position.start.column}` : ""}`
-              );
-            }
-          }
-          accumulator[field.name] = tree;
-          break;
-        case "object":
-          if (field.list) {
-            if (!value) {
-              return;
-            }
-            assertShape(
-              value,
-              (yup3) => yup3.array().of(yup3.object().required())
-            );
-            accumulator[field.name] = await sequential(value, async (item) => {
-              const template = await this.tinaSchema.getTemplateForData({
-                data: item,
-                collection: {
-                  namespace,
-                  ...field
-                }
-              });
-              const payload = {};
-              await sequential(template.fields, async (field2) => {
-                await this.resolveFieldData(field2, item, payload);
-              });
-              const isUnion = !!field.templates;
-              return isUnion ? {
-                _template: lastItem(template.namespace),
-                ...payload
-              } : payload;
-            });
-          } else {
-            if (!value) {
-              return;
-            }
-            const template = await this.tinaSchema.getTemplateForData({
-              data: value,
-              collection: {
-                namespace,
-                ...field
-              }
-            });
-            const payload = {};
-            await sequential(template.fields, async (field2) => {
-              await this.resolveFieldData(field2, value, payload);
-            });
-            const isUnion = !!field.templates;
-            accumulator[field.name] = isUnion ? {
-              _template: lastItem(template.namespace),
-              ...payload
-            } : payload;
-          }
-          break;
-        default:
-          return field;
-      }
-      return accumulator;
-    };
     this.buildParams = (args) => {
       try {
         assertShape(
@@ -4521,6 +4804,9 @@ var resolve = async ({
   try {
     const verboseValue = verbose ?? true;
     const graphQLSchemaAst = await database.getGraphQLSchema();
+    if (!graphQLSchemaAst) {
+      throw new GraphQLError3(`GraphQL schema not found`);
+    }
     const graphQLSchema = buildASTSchema(graphQLSchemaAst);
     const tinaConfig = await database.getTinaSchema();
     const tinaSchema = await createSchema({
@@ -4749,123 +5035,9 @@ var resolve = async ({
 };
 
 // src/database/index.ts
-import path3 from "path";
+import path4 from "path";
 import { GraphQLError as GraphQLError4 } from "graphql";
-import micromatch from "micromatch";
-
-// src/database/alias-utils.ts
-var replaceBlockAliases = (template, item) => {
-  const output = { ...item };
-  const templateKey = template.templateKey || "_template";
-  const templateName = output[templateKey];
-  const matchingTemplate = template.templates.find(
-    (t) => t.nameOverride == templateName || t.name == templateName
-  );
-  if (!matchingTemplate) {
-    throw new Error(
-      `Block template "${templateName}" is not defined for field "${template.name}"`
-    );
-  }
-  output._template = matchingTemplate.name;
-  if (templateKey != "_template") {
-    delete output[templateKey];
-  }
-  return output;
-};
-var replaceNameOverrides = (template, obj) => {
-  if (template.list) {
-    return obj.map((item) => {
-      if (isBlockField(template)) {
-        item = replaceBlockAliases(template, item);
-      }
-      return _replaceNameOverrides(
-        getTemplateForData(template, item).fields,
-        item
-      );
-    });
-  } else {
-    return _replaceNameOverrides(getTemplateForData(template, obj).fields, obj);
-  }
-};
-function isBlockField(field) {
-  return field && field.type === "object" && field.templates?.length > 0;
-}
-var _replaceNameOverrides = (fields, obj) => {
-  const output = {};
-  Object.keys(obj).forEach((key) => {
-    const field = fields.find(
-      (fieldWithMatchingAlias) => (fieldWithMatchingAlias?.nameOverride || fieldWithMatchingAlias?.name) === key
-    );
-    output[field?.name || key] = field?.type == "object" ? replaceNameOverrides(field, obj[key]) : obj[key];
-  });
-  return output;
-};
-var getTemplateForData = (field, data) => {
-  if (field.templates?.length) {
-    const templateKey = "_template";
-    if (data[templateKey]) {
-      const result = field.templates.find(
-        (template) => template.nameOverride === data[templateKey] || template.name === data[templateKey]
-      );
-      if (result) {
-        return result;
-      }
-      throw new Error(
-        `Template "${data[templateKey]}" is not defined for field "${field.name}"`
-      );
-    }
-    throw new Error(
-      `Missing required key "${templateKey}" on field "${field.name}"`
-    );
-  } else {
-    return field;
-  }
-};
-var applyBlockAliases = (template, item) => {
-  const output = { ...item };
-  const templateKey = template.templateKey || "_template";
-  const templateName = output._template;
-  const matchingTemplate = template.templates.find(
-    (t) => t.nameOverride == templateName || t.name == templateName
-  );
-  if (!matchingTemplate) {
-    throw new Error(
-      `Block template "${templateName}" is not defined for field "${template.name}"`
-    );
-  }
-  output[templateKey] = matchingTemplate.nameOverride || matchingTemplate.name;
-  if (templateKey != "_template") {
-    delete output._template;
-  }
-  return output;
-};
-var applyNameOverrides = (template, obj) => {
-  if (template.list) {
-    return obj.map((item) => {
-      let result = _applyNameOverrides(
-        getTemplateForData(template, item).fields,
-        item
-      );
-      if (isBlockField(template)) {
-        result = applyBlockAliases(template, result);
-      }
-      return result;
-    });
-  } else {
-    return _applyNameOverrides(getTemplateForData(template, obj).fields, obj);
-  }
-};
-var _applyNameOverrides = (fields, obj) => {
-  const output = {};
-  Object.keys(obj).forEach((key) => {
-    const field = fields.find((field2) => field2.name === key);
-    const outputKey = field?.nameOverride || key;
-    output[outputKey] = field?.type === "object" ? applyNameOverrides(field, obj[key]) : obj[key];
-  });
-  return output;
-};
-
-// src/database/index.ts
+import micromatch2 from "micromatch";
 import sha2 from "js-sha1";
 var createDatabase = (config) => {
   return new Database({
@@ -4883,16 +5055,17 @@ var Database = class {
     this.config = config;
     this.collectionForPath = async (filepath) => {
       const tinaSchema = await this.getSchema(this.level);
-      return tinaSchema.getCollectionByFullPath(filepath);
+      try {
+        return tinaSchema.getCollectionByFullPath(filepath);
+      } catch (e) {
+      }
     };
-    this.getGeneratedFolder = () => path3.join(this.tinaDirectory, "__generated__");
+    this.getGeneratedFolder = () => path4.join(this.tinaDirectory, "__generated__");
     this.get = async (filepath) => {
       await this.initLevel();
       if (SYSTEM_FILES.includes(filepath)) {
         throw new Error(`Unexpected get for config file ${filepath}`);
       } else {
-        const tinaSchema = await this.getSchema(this.level);
-        const extension = path3.extname(filepath);
         const contentObject = await this.level.sublevel(
           CONTENT_ROOT_PREFIX,
           SUBLEVEL_OPTIONS
@@ -4900,56 +5073,27 @@ var Database = class {
         if (!contentObject) {
           throw new GraphQLError4(`Unable to find record ${filepath}`);
         }
-        const templateName = hasOwnProperty(contentObject, "_template") && typeof contentObject._template === "string" ? contentObject._template : void 0;
-        const { collection, template } = hasOwnProperty(
+        return transformDocument(
+          filepath,
           contentObject,
-          "__collection"
-        ) ? {
-          collection: tinaSchema.getCollection(
-            contentObject["__collection"]
-          ),
-          template: void 0
-        } : tinaSchema.getCollectionAndTemplateByFullPath(filepath, templateName);
-        const field = template?.fields.find((field2) => {
-          if (field2.type === "string" || field2.type === "rich-text") {
-            if (field2.isBody) {
-              return true;
-            }
-          }
-          return false;
-        });
-        let data = contentObject;
-        if ((extension === ".md" || extension === ".mdx") && field) {
-          if (hasOwnProperty(contentObject, "$_body")) {
-            const { $_body, ...rest } = contentObject;
-            data = rest;
-            data[field.name] = $_body;
-          }
-        }
-        return {
-          ...data,
-          _collection: collection.name,
-          _keepTemplateKey: !!collection.templates,
-          _template: template?.namespace ? lastItem(template?.namespace) : void 0,
-          _relativePath: filepath.replace(collection.path, "").replace(/^\/|\/$/g, ""),
-          _id: filepath
-        };
+          await this.getSchema(this.level)
+        );
       }
     };
     this.addPendingDocument = async (filepath, data) => {
       await this.initLevel();
       const dataFields = await this.formatBodyOnPayload(filepath, data);
       const collection = await this.collectionForPath(filepath);
+      if (!collection) {
+        throw new GraphQLError4(`Unable to find collection for ${filepath}`);
+      }
       const stringifiedFile = await this.stringifyFile(
         filepath,
         dataFields,
         collection
       );
-      let collectionIndexDefinitions;
-      if (collection) {
-        const indexDefinitions = await this.getIndexDefinitions(this.level);
-        collectionIndexDefinitions = indexDefinitions?.[collection.name];
-      }
+      const indexDefinitions = await this.getIndexDefinitions(this.level);
+      const collectionIndexDefinitions = indexDefinitions?.[collection.name];
       const normalizedPath = normalizePath(filepath);
       if (this.bridge) {
         await this.bridge.put(normalizedPath, stringifiedFile);
@@ -5026,9 +5170,12 @@ var Database = class {
           const normalizedPath = normalizePath(filepath);
           const dataFields = await this.formatBodyOnPayload(filepath, data);
           const collection = await this.collectionForPath(filepath);
+          if (!collection) {
+            throw new GraphQLError4(`Unable to find collection for ${filepath}.`);
+          }
           if (collection.match?.exclude || collection.match?.include) {
             const matches = this.tinaSchema.getMatches({ collection });
-            const match = micromatch.isMatch(filepath, matches);
+            const match = micromatch2.isMatch(filepath, matches);
             if (!match) {
               throw new GraphQLError4(
                 `File ${filepath} does not match collection ${collection.name} glob ${matches.join(
@@ -5117,8 +5264,10 @@ var Database = class {
       }
     };
     this.formatBodyOnPayload = async (filepath, data) => {
-      const tinaSchema = await this.getSchema(this.level);
-      const collection = tinaSchema.getCollectionByFullPath(filepath);
+      const collection = await this.collectionForPath(filepath);
+      if (!collection) {
+        throw new Error(`Unable to find collection for path ${filepath}`);
+      }
       const { template } = await this.getTemplateDetailsForFile(collection, data);
       const bodyField = template.fields.find((field) => {
         if (field.type === "string" || field.type === "rich-text") {
@@ -5148,7 +5297,7 @@ var Database = class {
       );
       const writeTemplateKey = templateDetails.info.type === "union";
       const aliasedData = applyNameOverrides(templateDetails.template, payload);
-      const extension = path3.extname(filepath);
+      const extension = path4.extname(filepath);
       const stringifiedFile = stringifyFile(
         aliasedData,
         extension,
@@ -5164,6 +5313,9 @@ var Database = class {
       const data = await this.get(filepath);
       const dataFields = await this.formatBodyOnPayload(filepath, data);
       const collection = await this.collectionForPath(filepath);
+      if (!collection) {
+        throw new Error(`Unable to find collection for path ${filepath}`);
+      }
       const stringifiedFile = await this.stringifyFile(
         filepath,
         dataFields,
@@ -5174,7 +5326,7 @@ var Database = class {
     this.getLookup = async (returnType) => {
       await this.initLevel();
       const lookupPath = normalizePath(
-        path3.join(this.getGeneratedFolder(), `_lookup.json`)
+        path4.join(this.getGeneratedFolder(), `_lookup.json`)
       );
       if (!this._lookup) {
         const _lookup = await this.level.sublevel(
@@ -5188,7 +5340,7 @@ var Database = class {
     this.getGraphQLSchema = async () => {
       await this.initLevel();
       const graphqlPath = normalizePath(
-        path3.join(this.getGeneratedFolder(), `_graphql.json`)
+        path4.join(this.getGeneratedFolder(), `_graphql.json`)
       );
       return await this.level.sublevel(
         CONTENT_ROOT_PREFIX,
@@ -5200,7 +5352,7 @@ var Database = class {
         throw new Error(`No bridge configured`);
       }
       const graphqlPath = normalizePath(
-        path3.join(this.getGeneratedFolder(), `_graphql.json`)
+        path4.join(this.getGeneratedFolder(), `_graphql.json`)
       );
       const _graphql = await this.bridge.get(graphqlPath);
       return JSON.parse(_graphql);
@@ -5208,7 +5360,7 @@ var Database = class {
     this.getTinaSchema = async (level) => {
       await this.initLevel();
       const schemaPath = normalizePath(
-        path3.join(this.getGeneratedFolder(), `_schema.json`)
+        path4.join(this.getGeneratedFolder(), `_schema.json`)
       );
       return await (level || this.level).sublevel(
         CONTENT_ROOT_PREFIX,
@@ -5224,7 +5376,7 @@ var Database = class {
       if (!schema) {
         throw new Error(
           `Unable to get schema from level db: ${normalizePath(
-            path3.join(this.getGeneratedFolder(), `_schema.json`)
+            path4.join(this.getGeneratedFolder(), `_schema.json`)
           )}`
         );
       }
@@ -5438,7 +5590,7 @@ var Database = class {
             lookup = lookupFromLockFile || JSON.parse(
               await this.bridge.get(
                 normalizePath(
-                  path3.join(this.getGeneratedFolder(), "_lookup.json")
+                  path4.join(this.getGeneratedFolder(), "_lookup.json")
                 )
               )
             );
@@ -5462,15 +5614,15 @@ var Database = class {
           }
           const contentRootLevel = nextLevel.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS);
           await contentRootLevel.put(
-            normalizePath(path3.join(this.getGeneratedFolder(), "_graphql.json")),
+            normalizePath(path4.join(this.getGeneratedFolder(), "_graphql.json")),
             graphQLSchema
           );
           await contentRootLevel.put(
-            normalizePath(path3.join(this.getGeneratedFolder(), "_schema.json")),
+            normalizePath(path4.join(this.getGeneratedFolder(), "_schema.json")),
             tinaSchema.schema
           );
           await contentRootLevel.put(
-            normalizePath(path3.join(this.getGeneratedFolder(), "_lookup.json")),
+            normalizePath(path4.join(this.getGeneratedFolder(), "_lookup.json")),
             lookup
           );
           const result = await this._indexAllContent(
@@ -5501,8 +5653,9 @@ var Database = class {
           await this.level.batch(operations.splice(0, 25));
         }
       };
+      const tinaSchema = await this.getSchema(this.level);
       await this.indexStatusCallbackWrapper(async () => {
-        const { pathsByCollection, nonCollectionPaths, collections } = await this.partitionPathsByCollection(documentPaths);
+        const { pathsByCollection, nonCollectionPaths, collections } = await partitionPathsByCollection(tinaSchema, documentPaths);
         for (const collection of Object.keys(pathsByCollection)) {
           await _deleteIndexContent(
             this,
@@ -5528,18 +5681,25 @@ var Database = class {
           await this.level.batch(operations.splice(0, 25));
         }
       };
+      const tinaSchema = await this.getSchema(this.level);
       await this.indexStatusCallbackWrapper(async () => {
-        const { pathsByCollection, nonCollectionPaths, collections } = await this.partitionPathsByCollection(documentPaths);
-        for (const collection of Object.keys(pathsByCollection)) {
-          await _indexContent(
-            this,
-            this.level,
-            pathsByCollection[collection],
-            enqueueOps,
-            collections[collection]
-          );
-        }
-        await _indexContent(this, this.level, nonCollectionPaths, enqueueOps);
+        await scanContentByPaths(
+          tinaSchema,
+          documentPaths,
+          async (collection, documentPaths2) => {
+            if (collection) {
+              await _indexContent(
+                this,
+                this.level,
+                documentPaths2,
+                enqueueOps,
+                collection
+              );
+            } else {
+              await _indexContent(this, this.level, documentPaths2, enqueueOps);
+            }
+          }
+        );
       });
       while (operations.length) {
         await this.level.batch(operations.splice(0, 25));
@@ -5548,11 +5708,11 @@ var Database = class {
     this.delete = async (filepath) => {
       await this.initLevel();
       const collection = await this.collectionForPath(filepath);
-      let collectionIndexDefinitions;
-      if (collection) {
-        const indexDefinitions = await this.getIndexDefinitions(this.level);
-        collectionIndexDefinitions = indexDefinitions?.[collection.name];
+      if (!collection) {
+        throw new Error(`No collection found for path: ${filepath}`);
       }
+      const indexDefinitions = await this.getIndexDefinitions(this.level);
+      const collectionIndexDefinitions = indexDefinitions?.[collection.name];
       this.level.sublevel(
         CONTENT_ROOT_PREFIX,
         SUBLEVEL_OPTIONS
@@ -5599,7 +5759,6 @@ var Database = class {
       await this.onDelete(normalizePath(filepath));
     };
     this._indexAllContent = async (level, schema) => {
-      const warnings = [];
       const tinaSchema = await this.getSchema(level, schema);
       const operations = [];
       const enqueueOps = async (ops) => {
@@ -5609,33 +5768,13 @@ var Database = class {
           await level.batch(batchOps);
         }
       };
-      const filesSeen = /* @__PURE__ */ new Map();
-      const duplicateFiles = /* @__PURE__ */ new Set();
-      await sequential(tinaSchema.getCollections(), async (collection) => {
-        const normalPath = normalizePath(collection.path);
-        const format = collection.format || "md";
-        const documentPaths = await this.bridge.glob(normalPath, format);
-        const matches = this.tinaSchema.getMatches({ collection });
-        const filteredPaths = matches.length > 0 ? micromatch(documentPaths, matches) : documentPaths;
-        filteredPaths.forEach((path5) => {
-          if (filesSeen.has(path5)) {
-            filesSeen.get(path5).push(collection.name);
-            duplicateFiles.add(path5);
-          } else {
-            filesSeen.set(path5, [collection.name]);
-          }
-        });
-        duplicateFiles.forEach((path5) => {
-          warnings.push(
-            `"${path5}" Found in multiple collections: ${filesSeen.get(path5).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/
-`
-          );
-        });
-        await _indexContent(this, level, filteredPaths, enqueueOps, collection);
-      });
+      const warnings = await scanAllContent(
+        tinaSchema,
+        this.bridge,
+        async (collection, contentPaths) => {
+          await _indexContent(this, level, contentPaths, enqueueOps, collection);
+        }
+      );
       while (operations.length) {
         await level.batch(operations.splice(0, 25));
       }
@@ -5648,24 +5787,6 @@ This will be an error in the future. See https://tina.io/docs/errors/file-in-mut
     this.onPut = config.onPut || defaultOnPut;
     this.onDelete = config.onDelete || defaultOnDelete;
   }
-  async partitionPathsByCollection(documentPaths) {
-    const pathsByCollection = {};
-    const nonCollectionPaths = [];
-    const collections = {};
-    for (const documentPath of documentPaths) {
-      const collection = await this.collectionForPath(documentPath);
-      if (collection) {
-        if (!pathsByCollection[collection.name]) {
-          pathsByCollection[collection.name] = [];
-        }
-        collections[collection.name] = collection;
-        pathsByCollection[collection.name].push(documentPath);
-      } else {
-        nonCollectionPaths.push(documentPath);
-      }
-    }
-    return { pathsByCollection, nonCollectionPaths, collections };
-  }
   async updateDatabaseVersion(version) {
     const metadataLevel = this.rootLevel.sublevel("_metadata", SUBLEVEL_OPTIONS);
     await metadataLevel.put("metadata", { version });
@@ -5685,7 +5806,10 @@ This will be an error in the future. See https://tina.io/docs/errors/file-in-mut
       let version = await this.getDatabaseVersion();
       if (!version) {
         version = "";
-        await this.updateDatabaseVersion(version);
+        try {
+          await this.updateDatabaseVersion(version);
+        } catch (e) {
+        }
       }
       this.level = this.rootLevel.sublevel(version, SUBLEVEL_OPTIONS);
     }
@@ -5738,9 +5862,6 @@ This will be an error in the future. See https://tina.io/docs/errors/file-in-mut
     }
   }
 };
-function hasOwnProperty(obj, prop) {
-  return obj.hasOwnProperty(prop);
-}
 var _indexContent = async (database, level, documentPaths, enqueueOps, collection) => {
   let collectionIndexDefinitions;
   let collectionPath;
@@ -5760,29 +5881,17 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
   const folderTreeBuilder = new FolderTreeBuilder();
   await sequential(documentPaths, async (filepath) => {
     try {
-      const dataString = await database.bridge.get(normalizePath(filepath));
-      const data = parseFile(
-        dataString,
-        path3.extname(filepath),
-        (yup3) => yup3.object({}),
-        {
-          frontmatterDelimiters: collection?.frontmatterDelimiters,
-          frontmatterFormat: collection?.frontmatterFormat
-        }
+      const aliasedData = await loadAndParseWithAliases(
+        database.bridge,
+        filepath,
+        collection,
+        templateInfo
       );
-      const template = getTemplateForFile(templateInfo, data);
-      if (!template) {
-        console.warn(
-          `Document: ${filepath} has an ambiguous template, skipping from indexing`
-        );
-        return;
-      }
       const normalizedPath = normalizePath(filepath);
       const folderKey = folderTreeBuilder.update(
         normalizedPath,
         collectionPath || ""
       );
-      const aliasedData = templateInfo ? replaceNameOverrides(template, data) : data;
       await enqueueOps([
         ...makeIndexOpsForDocument(
           normalizedPath,
@@ -5814,7 +5923,7 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
       throw new TinaFetchError(`Unable to seed ${filepath}`, {
         originalError: error,
         file: filepath,
-        collection: collection.name,
+        collection: collection?.name,
         stack: error.stack
       });
     }
@@ -5898,27 +6007,6 @@ var _deleteIndexContent = async (database, documentPaths, enqueueOps, collection
     );
   }
 };
-var getTemplateForFile = (templateInfo, data) => {
-  if (templateInfo.type === "object") {
-    return templateInfo.template;
-  }
-  if (templateInfo.type === "union") {
-    if (hasOwnProperty(data, "_template")) {
-      const template = templateInfo.templates.find(
-        (t) => lastItem(t.namespace) === data._template
-      );
-      if (!template) {
-        throw new Error(
-          `Unable to find template "${data._template}". Possible templates are: ${templateInfo.templates.map((template2) => `"${template2.name}"`).join(", ")}.`
-        );
-      }
-      return template;
-    } else {
-      return void 0;
-    }
-  }
-  throw new Error(`Unable to determine template`);
-};
 
 // src/level/tinaLevel.ts
 import { ManyLevelGuest } from "many-level";
@@ -5944,7 +6032,7 @@ var TinaLevelClient = class extends ManyLevelGuest {
 // src/database/bridge/filesystem.ts
 import fs from "fs-extra";
 import fg from "fast-glob";
-import path4 from "path";
+import path5 from "path";
 import normalize from "normalize-path";
 var FilesystemBridge = class {
   constructor(rootPath, outputPath) {
@@ -5952,9 +6040,9 @@ var FilesystemBridge = class {
     this.outputPath = outputPath || rootPath;
   }
   async glob(pattern, extension) {
-    const basePath = path4.join(this.outputPath, ...pattern.split("/"));
+    const basePath = path5.join(this.outputPath, ...pattern.split("/"));
     const items = await fg(
-      path4.join(basePath, "**", `/*.${extension}`).replace(/\\/g, "/"),
+      path5.join(basePath, "**", `/*.${extension}`).replace(/\\/g, "/"),
       {
         dot: true,
         ignore: ["**/node_modules/**"]
@@ -5966,14 +6054,14 @@ var FilesystemBridge = class {
     });
   }
   async delete(filepath) {
-    await fs.remove(path4.join(this.outputPath, filepath));
+    await fs.remove(path5.join(this.outputPath, filepath));
   }
   async get(filepath) {
-    return fs.readFileSync(path4.join(this.outputPath, filepath)).toString();
+    return fs.readFileSync(path5.join(this.outputPath, filepath)).toString();
   }
   async put(filepath, data, basePathOverride) {
     const basePath = basePathOverride || this.outputPath;
-    await fs.outputFileSync(path4.join(basePath, filepath), data);
+    await fs.outputFileSync(path5.join(basePath, filepath), data);
   }
 };
 var AuditFileSystemBridge = class extends FilesystemBridge {
@@ -6057,7 +6145,7 @@ var IsomorphicBridge = class {
   async listEntries({
     pattern,
     entry,
-    path: path5,
+    path: path6,
     results
   }) {
     const treeResult = await git.readTree({
@@ -6067,7 +6155,7 @@ var IsomorphicBridge = class {
     });
     const children = [];
     for (const childEntry of treeResult.tree) {
-      const childPath = path5 ? `${path5}/${childEntry.path}` : childEntry.path;
+      const childPath = path6 ? `${path6}/${childEntry.path}` : childEntry.path;
       if (childEntry.type === "tree") {
         children.push(childEntry);
       } else {
@@ -6077,7 +6165,7 @@ var IsomorphicBridge = class {
       }
     }
     for (const childEntry of children) {
-      const childPath = path5 ? `${path5}/${childEntry.path}` : childEntry.path;
+      const childPath = path6 ? `${path6}/${childEntry.path}` : childEntry.path;
       await this.listEntries({
         pattern,
         entry: childEntry,
@@ -6086,17 +6174,17 @@ var IsomorphicBridge = class {
       });
     }
   }
-  async resolvePathEntries(path5, ref) {
-    let pathParts = path5.split("/");
+  async resolvePathEntries(path6, ref) {
+    let pathParts = path6.split("/");
     const result = await git.walk({
       ...this.isomorphicConfig,
       map: async (filepath, [head]) => {
         if (head._fullpath === ".") {
           return head;
         }
-        if (path5.startsWith(filepath)) {
-          if (dirname(path5) === dirname(filepath)) {
-            if (path5 === filepath) {
+        if (path6.startsWith(filepath)) {
+          if (dirname(path6) === dirname(filepath)) {
+            if (path6 === filepath) {
               return head;
             }
           } else {
@@ -6116,7 +6204,7 @@ var IsomorphicBridge = class {
     }
     return { pathParts, pathEntries };
   }
-  async updateTreeHierarchy(existingOid, updatedOid, path5, type, pathEntries, pathParts) {
+  async updateTreeHierarchy(existingOid, updatedOid, path6, type, pathEntries, pathParts) {
     const lastIdx = pathEntries.length - 1;
     const parentEntry = pathEntries[lastIdx];
     const parentPath = pathParts[lastIdx];
@@ -6131,7 +6219,7 @@ var IsomorphicBridge = class {
         cache: this.cache
       });
       tree = existingOid ? treeResult.tree.map((entry) => {
-        if (entry.path === path5) {
+        if (entry.path === path6) {
           entry.oid = updatedOid;
         }
         return entry;
@@ -6140,7 +6228,7 @@ var IsomorphicBridge = class {
         {
           oid: updatedOid,
           type,
-          path: path5,
+          path: path6,
           mode
         }
       ];
@@ -6149,7 +6237,7 @@ var IsomorphicBridge = class {
         {
           oid: updatedOid,
           type,
-          path: path5,
+          path: path6,
           mode
         }
       ];
@@ -6250,7 +6338,7 @@ var IsomorphicBridge = class {
       path: parentPath,
       results
     });
-    return results.map((path5) => this.unqualifyPath(path5)).filter((path5) => path5.endsWith(extension));
+    return results.map((path6) => this.unqualifyPath(path6)).filter((path6) => path6.endsWith(extension));
   }
   async delete(filepath) {
     const ref = await this.getRef();
@@ -6401,8 +6489,13 @@ export {
   createDatabase,
   createSchema,
   handleFetchErrorError,
+  loadAndParseWithAliases,
   parseFile,
   resolve,
+  scanAllContent,
+  scanContentByPaths,
   sequential,
-  stringifyFile
+  stringifyFile,
+  transformDocument,
+  transformDocumentIntoPayload
 };