@tinacms/graphql 0.0.0-d7c745e-20250102002342 → 0.0.0-d9487bf-20251119052214

package/dist/index.mjs

@@ -1029,41 +1029,6 @@ function* walk(maybeNode, visited = /* @__PURE__ */ new WeakSet()) {
   yield maybeNode;
   visited.add(maybeNode);
 }
-function addNamespaceToSchema(maybeNode, namespace = []) {
-  if (typeof maybeNode === "string") {
-    return maybeNode;
-  }
-  if (typeof maybeNode === "boolean") {
-    return maybeNode;
-  }
-  const newNode = maybeNode;
-  const keys = Object.keys(maybeNode);
-  Object.values(maybeNode).map((m, index) => {
-    const key = keys[index];
-    if (Array.isArray(m)) {
-      newNode[key] = m.map((element) => {
-        if (!element) {
-          return;
-        }
-        if (!element.hasOwnProperty("name")) {
-          return element;
-        }
-        const value = element.name || element.value;
-        return addNamespaceToSchema(element, [...namespace, value]);
-      });
-    } else {
-      if (!m) {
-        return;
-      }
-      if (!m.hasOwnProperty("name")) {
-        newNode[key] = m;
-      } else {
-        newNode[key] = addNamespaceToSchema(m, [...namespace, m.name]);
-      }
-    }
-  });
-  return { ...newNode, namespace };
-}
 var generateNamespacedFieldName = (names, suffix = "") => {
   return (suffix ? [...names, suffix] : names).map(capitalize).join("");
 };
@@ -1882,7 +1847,7 @@ var Builder = class {
      * ```
      *
      * @public
-     * @param collection a Tina Cloud collection
+     * @param collection a TinaCloud collection
      */
     this.collectionFragment = async (collection) => {
       const name = NAMER.dataTypeName(collection.namespace);
@@ -2746,7 +2711,7 @@ var Builder = class {
     this._buildDataField = async (field) => {
       const listWarningMsg = `
 WARNING: The user interface for ${field.type} does not support \`list: true\`
-Visit https://tina.io/docs/errors/ui-not-supported/ for more information
+Visit https://tina.io/docs/r/content-fields/#list-fields/ for more information
 
 `;
       switch (field.type) {
@@ -2898,6 +2863,7 @@ var filterSelections = (arr) => {
 import { TinaSchema } from "@tinacms/schema-tools";
 
 // src/schema/validate.ts
+import { addNamespaceToSchema } from "@tinacms/schema-tools";
 import deepClone from "lodash.clonedeep";
 import * as yup2 from "yup";
 import {
@@ -3053,7 +3019,7 @@ var validateField = async (field) => {
 // package.json
 var package_default = {
   name: "@tinacms/graphql",
-  version: "1.5.9",
+  version: "1.6.1",
   main: "dist/index.js",
   module: "dist/index.mjs",
   typings: "dist/index.d.ts",
@@ -3079,33 +3045,32 @@ var package_default = {
     types: "pnpm tsc",
     build: "tinacms-scripts build",
     docs: "pnpm typedoc",
-    serve: "pnpm nodemon dist/server.js",
-    test: "jest",
-    "test-watch": "jest --watch"
+    test: "vitest run",
+    "test-watch": "vitest"
   },
   dependencies: {
-    "@iarna/toml": "^2.2.5",
+    "@iarna/toml": "catalog:",
     "@tinacms/mdx": "workspace:*",
     "@tinacms/schema-tools": "workspace:*",
-    "abstract-level": "^1.0.4",
+    "abstract-level": "catalog:",
     "date-fns": "^2.30.0",
-    "fast-glob": "^3.3.2",
-    "fs-extra": "^11.2.0",
-    "glob-parent": "^6.0.2",
+    "fast-glob": "catalog:",
+    "fs-extra": "catalog:",
+    "glob-parent": "catalog:",
     graphql: "15.8.0",
-    "gray-matter": "^4.0.3",
-    "isomorphic-git": "^1.27.1",
-    "js-sha1": "^0.6.0",
+    "gray-matter": "catalog:",
+    "isomorphic-git": "catalog:",
+    "js-sha1": "catalog:",
     "js-yaml": "^3.14.1",
-    "jsonpath-plus": "10.1.0",
-    "lodash.clonedeep": "^4.5.0",
-    "lodash.set": "^4.3.2",
-    "lodash.uniqby": "^4.7.0",
-    "many-level": "^2.0.0",
-    micromatch: "4.0.8",
-    "normalize-path": "^3.0.0",
-    "readable-stream": "^4.5.2",
-    scmp: "^2.1.0",
+    "jsonpath-plus": "catalog:",
+    "lodash.clonedeep": "catalog:",
+    "lodash.set": "catalog:",
+    "lodash.uniqby": "catalog:",
+    "many-level": "catalog:",
+    micromatch: "catalog:",
+    "normalize-path": "catalog:",
+    "readable-stream": "catalog:",
+    scmp: "catalog:",
     yup: "^0.32.11"
   },
   publishConfig: {
@@ -3120,26 +3085,24 @@ var package_default = {
     "@tinacms/scripts": "workspace:*",
     "@types/cors": "^2.8.17",
     "@types/estree": "^0.0.50",
-    "@types/express": "^4.17.21",
+    "@types/express": "catalog:",
     "@types/fs-extra": "^9.0.13",
-    "@types/jest": "^26.0.24",
     "@types/js-yaml": "^3.12.10",
-    "@types/lodash.camelcase": "^4.3.9",
-    "@types/lodash.upperfirst": "^4.3.9",
-    "@types/lru-cache": "^5.1.1",
-    "@types/mdast": "^3.0.15",
-    "@types/micromatch": "^4.0.9",
-    "@types/node": "^22.9.0",
-    "@types/normalize-path": "^3.0.2",
-    "@types/ws": "^7.4.7",
+    "@types/lodash.camelcase": "catalog:",
+    "@types/lodash.upperfirst": "catalog:",
+    "@types/lru-cache": "catalog:",
+    "@types/mdast": "catalog:",
+    "@types/micromatch": "catalog:",
+    "@types/node": "^22.13.1",
+    "@types/normalize-path": "catalog:",
+    "@types/ws": "catalog:",
     "@types/yup": "^0.29.14",
-    jest: "^29.7.0",
-    "jest-diff": "^29.7.0",
     "jest-file-snapshot": "^0.5.0",
-    "jest-matcher-utils": "^29.7.0",
-    "memory-level": "^1.0.0",
-    nodemon: "3.1.4",
-    typescript: "^5.6.3"
+    "memory-level": "catalog:",
+    typescript: "^5.7.3",
+    vite: "^4.5.9",
+    vitest: "^0.32.4",
+    zod: "catalog:"
   }
 };
 
@@ -3295,7 +3258,9 @@ var _buildSchema = async (builder, tinaSchema) => {
     await builder.buildCreateCollectionFolderMutation()
   );
   await sequential(collections, async (collection) => {
-    queryTypeDefinitionFields.push(await builder.collectionDocument(collection));
+    queryTypeDefinitionFields.push(
+      await builder.collectionDocument(collection)
+    );
     if (collection.isAuthCollection) {
       queryTypeDefinitionFields.push(
         await builder.authenticationCollectionDocument(collection)
@@ -3345,249 +3310,10 @@ import { graphql, buildASTSchema, getNamedType, GraphQLError as GraphQLError4 }
 // src/resolver/index.ts
 import path3 from "path";
 import isValid from "date-fns/isValid/index.js";
-
-// src/mdx/index.ts
-import { parseMDX, stringifyMDX } from "@tinacms/mdx";
-
-// src/resolver/index.ts
 import { JSONPath as JSONPath2 } from "jsonpath-plus";
 
-// src/resolver/error.ts
-var TinaGraphQLError = class extends Error {
-  constructor(message, extensions) {
-    super(message);
-    if (!this.name) {
-      Object.defineProperty(this, "name", { value: "TinaGraphQLError" });
-    }
-    this.extensions = { ...extensions };
-  }
-};
-var TinaFetchError = class extends Error {
-  constructor(message, args) {
-    super(message);
-    this.name = "TinaFetchError";
-    this.collection = args.collection;
-    this.stack = args.stack;
-    this.file = args.file;
-    this.originalError = args.originalError;
-  }
-};
-var TinaQueryError = class extends TinaFetchError {
-  constructor(args) {
-    super(
-      `Error querying file ${args.file} from collection ${args.collection}. ${auditMessage(args.includeAuditMessage)}`,
-      args
-    );
-  }
-};
-var TinaParseDocumentError = class extends TinaFetchError {
-  constructor(args) {
-    super(
-      `Error parsing file ${args.file} from collection ${args.collection}. ${auditMessage(args.includeAuditMessage)}`,
-      args
-    );
-  }
-  toString() {
-    return super.toString() + "\n OriginalError: \n" + this.originalError.toString();
-  }
-};
-var auditMessage = (includeAuditMessage = true) => includeAuditMessage ? `Please run "tinacms audit" or add the --verbose option  for more info` : "";
-var handleFetchErrorError = (e, verbose) => {
-  if (e instanceof Error) {
-    if (e instanceof TinaFetchError) {
-      if (verbose) {
-        console.log(e.toString());
-        console.log(e);
-        console.log(e.stack);
-      }
-    }
-  } else {
-    console.error(e);
-  }
-  throw e;
-};
-
-// src/resolver/filter-utils.ts
-var resolveReferences = async (filter, fields, resolver) => {
-  for (const fieldKey of Object.keys(filter)) {
-    const fieldDefinition = fields.find(
-      (f) => f.name === fieldKey
-    );
-    if (fieldDefinition) {
-      if (fieldDefinition.type === "reference") {
-        const { edges, values } = await resolver(filter, fieldDefinition);
-        if (edges.length === 1) {
-          filter[fieldKey] = {
-            eq: values[0]
-          };
-        } else if (edges.length > 1) {
-          filter[fieldKey] = {
-            in: values
-          };
-        } else {
-          filter[fieldKey] = {
-            eq: "___null___"
-          };
-        }
-      } else if (fieldDefinition.type === "object") {
-        if (fieldDefinition.templates) {
-          for (const templateName of Object.keys(filter[fieldKey])) {
-            const template = fieldDefinition.templates.find(
-              (template2) => !(typeof template2 === "string") && template2.name === templateName
-            );
-            if (template) {
-              await resolveReferences(
-                filter[fieldKey][templateName],
-                template.fields,
-                resolver
-              );
-            } else {
-              throw new Error(`Template ${templateName} not found`);
-            }
-          }
-        } else {
-          await resolveReferences(
-            filter[fieldKey],
-            fieldDefinition.fields,
-            resolver
-          );
-        }
-      }
-    } else {
-      throw new Error(`Unable to find field ${fieldKey}`);
-    }
-  }
-};
-var collectConditionsForChildFields = (filterNode, fields, pathExpression, collectCondition) => {
-  for (const childFieldName of Object.keys(filterNode)) {
-    const childField = fields.find((field) => field.name === childFieldName);
-    if (!childField) {
-      throw new Error(`Unable to find type for field ${childFieldName}`);
-    }
-    collectConditionsForField(
-      childFieldName,
-      childField,
-      filterNode[childFieldName],
-      pathExpression,
-      collectCondition
-    );
-  }
-};
-var collectConditionsForObjectField = (fieldName, field, filterNode, pathExpression, collectCondition) => {
-  if (field.list && field.templates) {
-    for (const [filterKey, childFilterNode] of Object.entries(filterNode)) {
-      const template = field.templates.find(
-        (template2) => !(typeof template2 === "string") && template2.name === filterKey
-      );
-      const jsonPath = `${fieldName}[?(@._template=="${filterKey}")]`;
-      const filterPath = pathExpression ? `${pathExpression}.${jsonPath}` : jsonPath;
-      collectConditionsForChildFields(
-        childFilterNode,
-        template.fields,
-        filterPath,
-        collectCondition
-      );
-    }
-  } else {
-    const jsonPath = `${fieldName}${field.list ? "[*]" : ""}`;
-    const filterPath = pathExpression ? `${pathExpression}.${jsonPath}` : `${jsonPath}`;
-    collectConditionsForChildFields(
-      filterNode,
-      field.fields,
-      filterPath,
-      collectCondition
-    );
-  }
-};
-var collectConditionsForField = (fieldName, field, filterNode, pathExpression, collectCondition) => {
-  if (field.type === "object") {
-    collectConditionsForObjectField(
-      fieldName,
-      field,
-      filterNode,
-      pathExpression,
-      collectCondition
-    );
-  } else {
-    collectCondition({
-      filterPath: pathExpression ? `${pathExpression}.${fieldName}` : fieldName,
-      filterExpression: {
-        _type: field.type,
-        _list: !!field.list,
-        ...filterNode
-      }
-    });
-  }
-};
-
-// src/resolver/media-utils.ts
-var resolveMediaCloudToRelative = (value, config = { useRelativeMedia: true }, schema) => {
-  if (config && value) {
-    if (config.useRelativeMedia === true) {
-      return value;
-    }
-    if (hasTinaMediaConfig(schema) === true) {
-      const assetsURL = `https://${config.assetsHost}/${config.clientId}`;
-      if (typeof value === "string" && value.includes(assetsURL)) {
-        const cleanMediaRoot = cleanUpSlashes(
-          schema.config.media.tina.mediaRoot
-        );
-        const strippedURL = value.replace(assetsURL, "");
-        return `${cleanMediaRoot}${strippedURL}`;
-      }
-      if (Array.isArray(value)) {
-        return value.map((v) => {
-          if (!v || typeof v !== "string") return v;
-          const cleanMediaRoot = cleanUpSlashes(
-            schema.config.media.tina.mediaRoot
-          );
-          const strippedURL = v.replace(assetsURL, "");
-          return `${cleanMediaRoot}${strippedURL}`;
-        });
-      }
-      return value;
-    }
-    return value;
-  } else {
-    return value;
-  }
-};
-var resolveMediaRelativeToCloud = (value, config = { useRelativeMedia: true }, schema) => {
-  if (config && value) {
-    if (config.useRelativeMedia === true) {
-      return value;
-    }
-    if (hasTinaMediaConfig(schema) === true) {
-      const cleanMediaRoot = cleanUpSlashes(schema.config.media.tina.mediaRoot);
-      if (typeof value === "string") {
-        const strippedValue = value.replace(cleanMediaRoot, "");
-        return `https://${config.assetsHost}/${config.clientId}${strippedValue}`;
-      }
-      if (Array.isArray(value)) {
-        return value.map((v) => {
-          if (!v || typeof v !== "string") return v;
-          const strippedValue = v.replace(cleanMediaRoot, "");
-          return `https://${config.assetsHost}/${config.clientId}${strippedValue}`;
-        });
-      }
-    }
-    return value;
-  } else {
-    return value;
-  }
-};
-var cleanUpSlashes = (path7) => {
-  if (path7) {
-    return `/${path7.replace(/^\/+|\/+$/gm, "")}`;
-  }
-  return "";
-};
-var hasTinaMediaConfig = (schema) => {
-  if (!schema.config?.media?.tina) return false;
-  if (typeof schema.config?.media?.tina?.publicFolder !== "string" && typeof schema.config?.media?.tina?.mediaRoot !== "string")
-    return false;
-  return true;
-};
+// src/mdx/index.ts
+import { parseMDX, serializeMDX } from "@tinacms/mdx";
 
 // src/resolver/index.ts
 import { GraphQLError as GraphQLError2 } from "graphql";
@@ -3610,7 +3336,9 @@ var LevelProxyHandler = {
       throw new Error(`The property, ${property.toString()}, doesn't exist`);
     }
     if (typeof target[property] !== "function") {
-      throw new Error(`The property, ${property.toString()}, is not a function`);
+      throw new Error(
+        `The property, ${property.toString()}, is not a function`
+      );
     }
     if (property === "get") {
       return async (...args) => {
@@ -3648,13 +3376,13 @@ 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 micromatch from "micromatch";
+import matter from "gray-matter";
+import yaml from "js-yaml";
 import path from "path";
+import micromatch from "micromatch";
 
 // src/database/alias-utils.ts
 var replaceBlockAliases = (template, item) => {
@@ -3995,6 +3723,9 @@ var loadAndParseWithAliases = async (bridge, filepath, collection, templateInfo)
 
 // src/database/datalayer.ts
 var DEFAULT_COLLECTION_SORT_KEY = "__filepath__";
+var REFS_COLLECTIONS_SORT_KEY = "__refs__";
+var REFS_REFERENCE_FIELD = "__tina_ref__";
+var REFS_PATH_FIELD = "__tina_ref_path__";
 var DEFAULT_NUMERIC_LPAD = 4;
 var applyPadding = (input, pad) => {
   if (pad) {
@@ -4568,6 +4299,57 @@ var makeIndexOpsForDocument = (filepath, collection, indexDefinitions, data, opT
   }
   return result;
 };
+var makeRefOpsForDocument = (filepath, collection, references, data, opType, level) => {
+  const result = [];
+  if (collection) {
+    for (const [c, referencePaths] of Object.entries(references || {})) {
+      if (!referencePaths.length) {
+        continue;
+      }
+      const collectionSublevel = level.sublevel(c, SUBLEVEL_OPTIONS);
+      const refSublevel = collectionSublevel.sublevel(
+        REFS_COLLECTIONS_SORT_KEY,
+        SUBLEVEL_OPTIONS
+      );
+      const references2 = {};
+      for (const path7 of referencePaths) {
+        const ref = JSONPath({ path: path7, json: data });
+        if (!ref) {
+          continue;
+        }
+        if (Array.isArray(ref)) {
+          for (const r of ref) {
+            if (!r) {
+              continue;
+            }
+            if (references2[r]) {
+              references2[r].push(path7);
+            } else {
+              references2[r] = [path7];
+            }
+          }
+        } else {
+          if (references2[ref]) {
+            references2[ref].push(path7);
+          } else {
+            references2[ref] = [path7];
+          }
+        }
+      }
+      for (const ref of Object.keys(references2)) {
+        for (const path7 of references2[ref]) {
+          result.push({
+            type: opType,
+            key: `${ref}${INDEX_KEY_FIELD_SEPARATOR}${path7}${INDEX_KEY_FIELD_SEPARATOR}${filepath}`,
+            sublevel: refSublevel,
+            value: opType === "put" ? {} : void 0
+          });
+        }
+      }
+    }
+  }
+  return result;
+};
 var makeStringEscaper = (regex, replacement) => {
   return (input) => {
     if (Array.isArray(input)) {
@@ -4581,12 +4363,248 @@ var makeStringEscaper = (regex, replacement) => {
         return input;
       }
     }
-  };
+  };
+};
+var stringEscaper = makeStringEscaper(
+  new RegExp(INDEX_KEY_FIELD_SEPARATOR, "gm"),
+  encodeURIComponent(INDEX_KEY_FIELD_SEPARATOR)
+);
+
+// src/resolver/error.ts
+var TinaGraphQLError = class extends Error {
+  constructor(message, extensions) {
+    super(message);
+    if (!this.name) {
+      Object.defineProperty(this, "name", { value: "TinaGraphQLError" });
+    }
+    this.extensions = { ...extensions };
+  }
+};
+var TinaFetchError = class extends Error {
+  constructor(message, args) {
+    super(message);
+    this.name = "TinaFetchError";
+    this.collection = args.collection;
+    this.file = args.file;
+    this.originalError = args.originalError;
+  }
+};
+var TinaQueryError = class extends TinaFetchError {
+  constructor(args) {
+    super(
+      `Error querying file ${args.file} from collection ${args.collection}. ${auditMessage(args.includeAuditMessage)}`,
+      args
+    );
+  }
+};
+var TinaParseDocumentError = class extends TinaFetchError {
+  constructor(args) {
+    super(
+      `Error parsing file ${args.file} from collection ${args.collection}. ${auditMessage(args.includeAuditMessage)}`,
+      args
+    );
+  }
+  toString() {
+    return super.toString() + "\n OriginalError: \n" + this.originalError.toString();
+  }
+};
+var auditMessage = (includeAuditMessage = true) => includeAuditMessage ? `Please run "tinacms audit" or add the --verbose option  for more info` : "";
+var handleFetchErrorError = (e, verbose) => {
+  if (e instanceof Error) {
+    if (e instanceof TinaFetchError) {
+      if (verbose) {
+        console.log(e.toString());
+        console.log(e);
+        console.log(e.stack);
+      }
+    }
+  } else {
+    console.error(e);
+  }
+  throw e;
+};
+
+// src/resolver/filter-utils.ts
+var resolveReferences = async (filter, fields, resolver) => {
+  for (const fieldKey of Object.keys(filter)) {
+    const fieldDefinition = fields.find(
+      (f) => f.name === fieldKey
+    );
+    if (fieldDefinition) {
+      if (fieldDefinition.type === "reference") {
+        const { edges, values } = await resolver(filter, fieldDefinition);
+        if (edges.length === 1) {
+          filter[fieldKey] = {
+            eq: values[0]
+          };
+        } else if (edges.length > 1) {
+          filter[fieldKey] = {
+            in: values
+          };
+        } else {
+          filter[fieldKey] = {
+            eq: "___null___"
+          };
+        }
+      } else if (fieldDefinition.type === "object") {
+        if (fieldDefinition.templates) {
+          for (const templateName of Object.keys(filter[fieldKey])) {
+            const template = fieldDefinition.templates.find(
+              (template2) => !(typeof template2 === "string") && template2.name === templateName
+            );
+            if (template) {
+              await resolveReferences(
+                filter[fieldKey][templateName],
+                template.fields,
+                resolver
+              );
+            } else {
+              throw new Error(`Template ${templateName} not found`);
+            }
+          }
+        } else {
+          await resolveReferences(
+            filter[fieldKey],
+            fieldDefinition.fields,
+            resolver
+          );
+        }
+      }
+    } else {
+      throw new Error(`Unable to find field ${fieldKey}`);
+    }
+  }
+};
+var collectConditionsForChildFields = (filterNode, fields, pathExpression, collectCondition) => {
+  for (const childFieldName of Object.keys(filterNode)) {
+    const childField = fields.find((field) => field.name === childFieldName);
+    if (!childField) {
+      throw new Error(`Unable to find type for field ${childFieldName}`);
+    }
+    collectConditionsForField(
+      childFieldName,
+      childField,
+      filterNode[childFieldName],
+      pathExpression,
+      collectCondition
+    );
+  }
+};
+var collectConditionsForObjectField = (fieldName, field, filterNode, pathExpression, collectCondition) => {
+  if (field.list && field.templates) {
+    for (const [filterKey, childFilterNode] of Object.entries(filterNode)) {
+      const template = field.templates.find(
+        (template2) => !(typeof template2 === "string") && template2.name === filterKey
+      );
+      const jsonPath = `${fieldName}[?(@._template=="${filterKey}")]`;
+      const filterPath = pathExpression ? `${pathExpression}.${jsonPath}` : jsonPath;
+      collectConditionsForChildFields(
+        childFilterNode,
+        template.fields,
+        filterPath,
+        collectCondition
+      );
+    }
+  } else {
+    const jsonPath = `${fieldName}${field.list ? "[*]" : ""}`;
+    const filterPath = pathExpression ? `${pathExpression}.${jsonPath}` : `${jsonPath}`;
+    collectConditionsForChildFields(
+      filterNode,
+      field.fields,
+      filterPath,
+      collectCondition
+    );
+  }
+};
+var collectConditionsForField = (fieldName, field, filterNode, pathExpression, collectCondition) => {
+  if (field.type === "object") {
+    collectConditionsForObjectField(
+      fieldName,
+      field,
+      filterNode,
+      pathExpression,
+      collectCondition
+    );
+  } else {
+    collectCondition({
+      filterPath: pathExpression ? `${pathExpression}.${fieldName}` : fieldName,
+      filterExpression: {
+        _type: field.type,
+        _list: !!field.list,
+        ...filterNode
+      }
+    });
+  }
+};
+
+// src/resolver/media-utils.ts
+var resolveMediaCloudToRelative = (value, config = { useRelativeMedia: true }, schema) => {
+  if (config && value) {
+    if (config.useRelativeMedia === true) {
+      return value;
+    }
+    if (hasTinaMediaConfig(schema) === true) {
+      const assetsURL = `https://${config.assetsHost}/${config.clientId}`;
+      if (typeof value === "string" && value.includes(assetsURL)) {
+        const cleanMediaRoot = cleanUpSlashes(
+          schema.config.media.tina.mediaRoot
+        );
+        const strippedURL = value.replace(assetsURL, "");
+        return `${cleanMediaRoot}${strippedURL}`;
+      }
+      if (Array.isArray(value)) {
+        return value.map((v) => {
+          if (!v || typeof v !== "string") return v;
+          const cleanMediaRoot = cleanUpSlashes(
+            schema.config.media.tina.mediaRoot
+          );
+          const strippedURL = v.replace(assetsURL, "");
+          return `${cleanMediaRoot}${strippedURL}`;
+        });
+      }
+      return value;
+    }
+    return value;
+  } else {
+    return value;
+  }
+};
+var resolveMediaRelativeToCloud = (value, config = { useRelativeMedia: true }, schema) => {
+  if (config && value) {
+    if (config.useRelativeMedia === true) {
+      return value;
+    }
+    if (hasTinaMediaConfig(schema) === true) {
+      const cleanMediaRoot = cleanUpSlashes(schema.config.media.tina.mediaRoot);
+      if (typeof value === "string") {
+        const strippedValue = value.replace(cleanMediaRoot, "");
+        return `https://${config.assetsHost}/${config.clientId}${strippedValue}`;
+      }
+      if (Array.isArray(value)) {
+        return value.map((v) => {
+          if (!v || typeof v !== "string") return v;
+          const strippedValue = v.replace(cleanMediaRoot, "");
+          return `https://${config.assetsHost}/${config.clientId}${strippedValue}`;
+        });
+      }
+    }
+    return value;
+  } else {
+    return value;
+  }
+};
+var cleanUpSlashes = (path7) => {
+  if (path7) {
+    return `/${path7.replace(/^\/+|\/+$/gm, "")}`;
+  }
+  return "";
+};
+var hasTinaMediaConfig = (schema) => {
+  if (!schema.config?.media?.tina) return false;
+  if (typeof schema.config?.media?.tina?.publicFolder !== "string" && typeof schema.config?.media?.tina?.mediaRoot !== "string")
+    return false;
+  return true;
 };
-var stringEscaper = makeStringEscaper(
-  new RegExp(INDEX_KEY_FIELD_SEPARATOR, "gm"),
-  encodeURIComponent(INDEX_KEY_FIELD_SEPARATOR)
-);
 
 // src/resolver/index.ts
 var createResolver = (args) => {
@@ -4748,8 +4766,7 @@ var transformDocumentIntoPayload = async (fullPath, rawData, tinaSchema, config,
         originalError: e,
         collection: collection.name,
         includeAuditMessage: !isAudit,
-        file: relativePath,
-        stack: e.stack
+        file: relativePath
       });
     }
     const titleField = template.fields.find((x) => {
@@ -4788,24 +4805,33 @@ var transformDocumentIntoPayload = async (fullPath, rawData, tinaSchema, config,
     throw e;
   }
 };
-var updateObjectWithJsonPath = (obj, path7, newValue) => {
+var updateObjectWithJsonPath = (obj, path7, oldValue, newValue) => {
+  let updated = false;
   if (!path7.includes(".") && !path7.includes("[")) {
-    if (path7 in obj) {
+    if (path7 in obj && obj[path7] === oldValue) {
       obj[path7] = newValue;
+      updated = true;
     }
-    return obj;
-  }
-  const parentPath = path7.replace(/\.[^.]+$/, "");
-  const keyToUpdate = path7.match(/[^.]+$/)[0];
-  const parents = JSONPath2({ path: parentPath, json: obj, resultType: "value" });
+    return { object: obj, updated };
+  }
+  const parentPath = path7.replace(/\.[^.\[\]]+$/, "");
+  const keyToUpdate = path7.match(/[^.\[\]]+$/)[0];
+  const parents = JSONPath2({
+    path: parentPath,
+    json: obj,
+    resultType: "value"
+  });
   if (parents.length > 0) {
     parents.forEach((parent) => {
       if (parent && typeof parent === "object" && keyToUpdate in parent) {
-        parent[keyToUpdate] = newValue;
+        if (parent[keyToUpdate] === oldValue) {
+          parent[keyToUpdate] = newValue;
+          updated = true;
+        }
       }
     });
   }
-  return obj;
+  return { object: obj, updated };
 };
 var Resolver = class {
   constructor(init) {
@@ -4822,7 +4848,9 @@ var Resolver = class {
     };
     this.getRaw = async (fullPath) => {
       if (typeof fullPath !== "string") {
-        throw new Error(`fullPath must be of type string for getDocument request`);
+        throw new Error(
+          `fullPath must be of type string for getDocument request`
+        );
       }
       return this.database.get(fullPath);
     };
@@ -4851,7 +4879,9 @@ var Resolver = class {
     };
     this.getDocument = async (fullPath, opts = {}) => {
       if (typeof fullPath !== "string") {
-        throw new Error(`fullPath must be of type string for getDocument request`);
+        throw new Error(
+          `fullPath must be of type string for getDocument request`
+        );
       }
       const rawData = await this.getRaw(fullPath);
       const hasReferences = opts?.checkReferences ? await this.hasReferences(fullPath, opts.collection) : void 0;
@@ -4866,7 +4896,9 @@ var Resolver = class {
     };
     this.deleteDocument = async (fullPath) => {
       if (typeof fullPath !== "string") {
-        throw new Error(`fullPath must be of type string for getDocument request`);
+        throw new Error(
+          `fullPath must be of type string for getDocument request`
+        );
       }
       await this.database.delete(fullPath);
     };
@@ -5070,7 +5102,11 @@ var Resolver = class {
         collection,
         doc?._rawData
       );
-      await this.database.put(realPath, { ...oldDoc, ...params }, collection.name);
+      await this.database.put(
+        realPath,
+        { ...oldDoc, ...params },
+        collection.name
+      );
       return this.getDocument(realPath);
     };
     /**
@@ -5183,17 +5219,35 @@ var Resolver = class {
           await this.deleteDocument(realPath);
           if (await this.hasReferences(realPath, collection)) {
             const collRefs = await this.findReferences(realPath, collection);
-            for (const [collection2, refFields] of Object.entries(collRefs)) {
-              for (const [refPath, refs] of Object.entries(refFields)) {
-                let refDoc = await this.getRaw(refPath);
-                for (const ref of refs) {
-                  refDoc = updateObjectWithJsonPath(
+            for (const [collection2, docsWithRefs] of Object.entries(collRefs)) {
+              for (const [pathToDocWithRef, referencePaths] of Object.entries(
+                docsWithRefs
+              )) {
+                let refDoc = await this.getRaw(pathToDocWithRef);
+                let hasUpdate = false;
+                for (const path7 of referencePaths) {
+                  const { object: object2, updated } = updateObjectWithJsonPath(
                     refDoc,
-                    ref.path.join("."),
+                    path7,
+                    realPath,
                     null
                   );
+                  refDoc = object2;
+                  hasUpdate = updated || hasUpdate;
+                }
+                if (hasUpdate) {
+                  const collectionWithRef = this.tinaSchema.getCollectionByFullPath(pathToDocWithRef);
+                  if (!collectionWithRef) {
+                    throw new Error(
+                      `Unable to find collection for ${pathToDocWithRef}`
+                    );
+                  }
+                  await this.database.put(
+                    pathToDocWithRef,
+                    refDoc,
+                    collectionWithRef.name
+                  );
                 }
-                await this.database.put(refPath, refDoc, collection2);
               }
             }
           }
@@ -5213,26 +5267,49 @@ var Resolver = class {
             collection?.path,
             args.params.relativePath
           );
+          if (newRealPath === realPath) {
+            return doc;
+          }
           await this.database.put(newRealPath, doc._rawData, collection.name);
           await this.deleteDocument(realPath);
           const collRefs = await this.findReferences(realPath, collection);
-          for (const [collection2, refFields] of Object.entries(collRefs)) {
-            for (const [refPath, refs] of Object.entries(refFields)) {
-              let refDoc = await this.getRaw(refPath);
-              for (const ref of refs) {
-                refDoc = updateObjectWithJsonPath(
-                  refDoc,
-                  ref.path.join("."),
+          for (const [collection2, docsWithRefs] of Object.entries(collRefs)) {
+            for (const [pathToDocWithRef, referencePaths] of Object.entries(
+              docsWithRefs
+            )) {
+              let docWithRef = await this.getRaw(pathToDocWithRef);
+              let hasUpdate = false;
+              for (const path7 of referencePaths) {
+                const { object: object2, updated } = updateObjectWithJsonPath(
+                  docWithRef,
+                  path7,
+                  realPath,
                   newRealPath
                 );
+                docWithRef = object2;
+                hasUpdate = updated || hasUpdate;
+              }
+              if (hasUpdate) {
+                const collectionWithRef = this.tinaSchema.getCollectionByFullPath(pathToDocWithRef);
+                if (!collectionWithRef) {
+                  throw new Error(
+                    `Unable to find collection for ${pathToDocWithRef}`
+                  );
+                }
+                await this.database.put(
+                  pathToDocWithRef,
+                  docWithRef,
+                  collectionWithRef.name
+                );
               }
-              await this.database.put(refPath, refDoc, collection2);
             }
           }
           return this.getDocument(newRealPath);
         }
         if (alreadyExists === false) {
-          throw new Error(`Unable to update document, ${realPath} does not exist`);
+          throw new Error(
+            `Unable to update document, ${realPath} does not exist`
+          );
         }
         return this.updateResolveDocument({
           collection,
@@ -5358,35 +5435,30 @@ var Resolver = class {
      */
     this.hasReferences = async (id, c) => {
       let count = 0;
-      const deepRefs = this.tinaSchema.findReferences(c.name);
-      for (const [collection, refs] of Object.entries(deepRefs)) {
-        for (const ref of refs) {
-          await this.database.query(
-            {
-              collection,
-              filterChain: makeFilterChain({
-                conditions: [
-                  {
-                    filterPath: ref.path.join("."),
-                    filterExpression: {
-                      _type: "reference",
-                      _list: false,
-                      eq: id
-                    }
-                  }
-                ]
-              }),
-              sort: ref.field.name
-            },
-            (refId) => {
-              count++;
-              return refId;
-            }
-          );
-          if (count) {
-            return true;
-          }
+      await this.database.query(
+        {
+          collection: c.name,
+          filterChain: makeFilterChain({
+            conditions: [
+              {
+                filterPath: REFS_REFERENCE_FIELD,
+                filterExpression: {
+                  _type: "string",
+                  _list: false,
+                  eq: id
+                }
+              }
+            ]
+          }),
+          sort: REFS_COLLECTIONS_SORT_KEY
+        },
+        (refId) => {
+          count++;
+          return refId;
         }
+      );
+      if (count) {
+        return true;
       }
       return false;
     };
@@ -5394,46 +5466,41 @@ var Resolver = class {
      * Finds references to a document
      * @param id the id of the document to find references to
      * @param c the collection to find references in
-     * @returns references to the document in the form of a map of collection names to a list of fields that reference the document
+     * @returns a map of references to the document
      */
     this.findReferences = async (id, c) => {
       const references = {};
-      const deepRefs = this.tinaSchema.findReferences(c.name);
-      for (const [collection, refs] of Object.entries(deepRefs)) {
-        for (const ref of refs) {
-          await this.database.query(
-            {
-              collection,
-              filterChain: makeFilterChain({
-                conditions: [
-                  {
-                    filterPath: ref.path.join("."),
-                    filterExpression: {
-                      _type: "reference",
-                      _list: false,
-                      eq: id
-                    }
-                  }
-                ]
-              }),
-              sort: ref.field.name
-            },
-            (refId) => {
-              if (!references[collection]) {
-                references[collection] = {};
-              }
-              if (!references[collection][refId]) {
-                references[collection][refId] = [];
+      await this.database.query(
+        {
+          collection: c.name,
+          filterChain: makeFilterChain({
+            conditions: [
+              {
+                filterPath: REFS_REFERENCE_FIELD,
+                filterExpression: {
+                  _type: "string",
+                  _list: false,
+                  eq: id
+                }
               }
-              references[collection][refId].push({
-                path: ref.path,
-                field: ref.field
-              });
-              return refId;
-            }
-          );
+            ]
+          }),
+          sort: REFS_COLLECTIONS_SORT_KEY
+        },
+        (refId, rawItem) => {
+          if (!references[c.name]) {
+            references[c.name] = {};
+          }
+          if (!references[c.name][refId]) {
+            references[c.name][refId] = [];
+          }
+          const referencePath = rawItem?.[REFS_PATH_FIELD];
+          if (referencePath) {
+            references[c.name][refId].push(referencePath);
+          }
+          return refId;
         }
-      }
+      );
       return references;
     };
     this.buildFieldMutations = async (fieldParams, template, existingData) => {
@@ -5503,7 +5570,7 @@ var Resolver = class {
             }
             break;
           case "rich-text":
-            accum[fieldName] = stringifyMDX(
+            accum[fieldName] = serializeMDX(
               fieldValue,
               field,
               (fieldValue2) => resolveMediaCloudToRelative(
@@ -5610,8 +5677,129 @@ var resolveDateInput = (value) => {
   return date;
 };
 
-// src/resolve.ts
+// src/resolver/auth-fields.ts
 import set from "lodash.set";
+async function getUserDocumentContext(tinaSchema, resolver) {
+  const collection = tinaSchema.getCollections().find((c) => c.isAuthCollection);
+  if (!collection) {
+    throw new Error("Auth collection not found");
+  }
+  const userFields = mapUserFields(collection, ["_rawData"]);
+  if (!userFields.length) {
+    throw new Error(`No user field found in collection ${collection.name}`);
+  }
+  if (userFields.length > 1) {
+    throw new Error(
+      `Multiple user fields found in collection ${collection.name}`
+    );
+  }
+  const userField = userFields[0];
+  const realPath = `${collection.path}/index.json`;
+  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 };
+}
+function findUserInCollection(users, userField, userSub) {
+  const { idFieldName } = userField;
+  if (!idFieldName) {
+    throw new Error("No uid field found on user field");
+  }
+  return users.find((u) => u[idFieldName] === userSub) || null;
+}
+async function handleAuthenticate({
+  tinaSchema,
+  resolver,
+  sub,
+  password,
+  ctxUser
+}) {
+  const userSub = sub || ctxUser?.sub;
+  const { userField, users } = await getUserDocumentContext(
+    tinaSchema,
+    resolver
+  );
+  const user = findUserInCollection(users, userField, userSub);
+  if (!user) {
+    return null;
+  }
+  const { passwordFieldName } = userField;
+  const saltedHash = get(user, [passwordFieldName || "", "value"]);
+  if (!saltedHash) {
+    throw new Error("No password field found on user field");
+  }
+  const matches = await checkPasswordHash({
+    saltedHash,
+    password
+  });
+  return matches ? user : null;
+}
+async function handleAuthorize({
+  tinaSchema,
+  resolver,
+  sub,
+  ctxUser
+}) {
+  const userSub = sub || ctxUser?.sub;
+  const { userField, users } = await getUserDocumentContext(
+    tinaSchema,
+    resolver
+  );
+  const user = findUserInCollection(users, userField, userSub);
+  return user ? user : null;
+}
+async function handleUpdatePassword({
+  tinaSchema,
+  resolver,
+  password,
+  ctxUser
+}) {
+  if (!ctxUser?.sub) {
+    throw new Error("Not authorized");
+  }
+  if (!password) {
+    throw new Error("No password provided");
+  }
+  const { collection, userField, users, realPath } = await getUserDocumentContext(tinaSchema, resolver);
+  const { idFieldName, passwordFieldName } = userField;
+  const user = users.find((u) => u[idFieldName] === ctxUser.sub);
+  if (!user) {
+    throw new Error("Not authorized");
+  }
+  user[passwordFieldName] = {
+    value: password,
+    passwordChangeRequired: false
+  };
+  const params = {};
+  set(
+    params,
+    userField.path.slice(1),
+    // remove _rawData from users path
+    users.map((u) => {
+      if (user[idFieldName] === u[idFieldName]) {
+        return user;
+      }
+      return {
+        // don't overwrite other users' passwords
+        ...u,
+        [passwordFieldName]: {
+          ...u[passwordFieldName],
+          value: ""
+        }
+      };
+    })
+  );
+  await resolver.updateResolveDocument({
+    collection,
+    args: { params },
+    realPath,
+    isCollectionSpecific: true,
+    isAddPendingDocument: false
+  });
+  return true;
+}
 
 // src/error.ts
 import { GraphQLError as GraphQLError3 } from "graphql";
@@ -5721,119 +5909,33 @@ var resolve = async ({
               );
             }
           }
-          if (info.fieldName === "authenticate" || info.fieldName === "authorize") {
-            const sub = args.sub || ctxUser?.sub;
-            const collection = tinaSchema.getCollections().find((c) => c.isAuthCollection);
-            if (!collection) {
-              throw new Error("Auth collection not found");
-            }
-            const userFields = mapUserFields(collection, ["_rawData"]);
-            if (!userFields.length) {
-              throw new Error(
-                `No user field found in collection ${collection.name}`
-              );
-            }
-            if (userFields.length > 1) {
-              throw new Error(
-                `Multiple user fields found in collection ${collection.name}`
-              );
-            }
-            const userField = userFields[0];
-            const realPath = `${collection.path}/index.json`;
-            const userDoc = await resolver.getDocument(realPath);
-            const users = get(userDoc, userField.path);
-            if (!users) {
-              throw new Error("No users found");
-            }
-            const { idFieldName, passwordFieldName } = userField;
-            if (!idFieldName) {
-              throw new Error("No uid field found on user field");
-            }
-            const user = users.find((u) => u[idFieldName] === sub);
-            if (!user) {
-              return null;
-            }
-            if (info.fieldName === "authenticate") {
-              const saltedHash = get(user, [passwordFieldName || "", "value"]);
-              if (!saltedHash) {
-                throw new Error("No password field found on user field");
-              }
-              const matches = await checkPasswordHash({
-                saltedHash,
-                password: args.password
-              });
-              if (matches) {
-                return user;
-              }
-              return null;
-            }
-            return user;
+          if (info.fieldName === "authenticate") {
+            return handleAuthenticate({
+              tinaSchema,
+              resolver,
+              sub: args.sub,
+              password: args.password,
+              info,
+              ctxUser
+            });
+          }
+          if (info.fieldName === "authorize") {
+            return handleAuthorize({
+              tinaSchema,
+              resolver,
+              sub: args.sub,
+              info,
+              ctxUser
+            });
           }
           if (info.fieldName === "updatePassword") {
-            if (!ctxUser?.sub) {
-              throw new Error("Not authorized");
-            }
-            if (!args.password) {
-              throw new Error("No password provided");
-            }
-            const collection = tinaSchema.getCollections().find((c) => c.isAuthCollection);
-            if (!collection) {
-              throw new Error("Auth collection not found");
-            }
-            const userFields = mapUserFields(collection, ["_rawData"]);
-            if (!userFields.length) {
-              throw new Error(
-                `No user field found in collection ${collection.name}`
-              );
-            }
-            if (userFields.length > 1) {
-              throw new Error(
-                `Multiple user fields found in collection ${collection.name}`
-              );
-            }
-            const userField = userFields[0];
-            const realPath = `${collection.path}/index.json`;
-            const userDoc = await resolver.getDocument(realPath);
-            const users = get(userDoc, userField.path);
-            if (!users) {
-              throw new Error("No users found");
-            }
-            const { idFieldName, passwordFieldName } = userField;
-            const user = users.find((u) => u[idFieldName] === ctxUser.sub);
-            if (!user) {
-              throw new Error("Not authorized");
-            }
-            user[passwordFieldName] = {
-              value: args.password,
-              passwordChangeRequired: false
-            };
-            const params = {};
-            set(
-              params,
-              userField.path.slice(1),
-              // remove _rawData from users path
-              users.map((u) => {
-                if (user[idFieldName] === u[idFieldName]) {
-                  return user;
-                }
-                return {
-                  // don't overwrite other users' passwords
-                  ...u,
-                  [passwordFieldName]: {
-                    ...u[passwordFieldName],
-                    value: ""
-                  }
-                };
-              })
-            );
-            await resolver.updateResolveDocument({
-              collection,
-              args: { params },
-              realPath,
-              isCollectionSpecific: true,
-              isAddPendingDocument: false
+            return handleUpdatePassword({
+              tinaSchema,
+              resolver,
+              password: args.password,
+              info,
+              ctxUser
             });
-            return true;
           }
           if (!lookup) {
             return value;
@@ -6177,6 +6279,7 @@ var Database = class {
       );
       const indexDefinitions = await this.getIndexDefinitions(this.contentLevel);
       const collectionIndexDefinitions = indexDefinitions?.[collection.name];
+      const collectionReferences = (await this.getCollectionReferences())?.[collection.name];
       const normalizedPath = normalizePath(filepath);
       if (!collection?.isDetached) {
         if (this.bridge) {
@@ -6205,6 +6308,14 @@ var Database = class {
       let delOps = [];
       if (!isGitKeep(normalizedPath, collection)) {
         putOps = [
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection?.name,
+            collectionReferences,
+            dataFields,
+            "put",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection?.name,
@@ -6228,6 +6339,14 @@ var Database = class {
           SUBLEVEL_OPTIONS
         ).get(normalizedPath);
         delOps = existingItem ? [
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection?.name,
+            collectionReferences,
+            existingItem,
+            "del",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection?.name,
@@ -6275,6 +6394,7 @@ var Database = class {
             );
             collectionIndexDefinitions = indexDefinitions?.[collectionName];
           }
+          const collectionReferences = (await this.getCollectionReferences())?.[collectionName];
           const normalizedPath = normalizePath(filepath);
           const dataFields = await this.formatBodyOnPayload(filepath, data);
           const collection = await this.collectionForPath(filepath);
@@ -6322,6 +6442,14 @@ var Database = class {
           let delOps = [];
           if (!isGitKeep(normalizedPath, collection)) {
             putOps = [
+              ...makeRefOpsForDocument(
+                normalizedPath,
+                collectionName,
+                collectionReferences,
+                dataFields,
+                "put",
+                level
+              ),
               ...makeIndexOpsForDocument(
                 normalizedPath,
                 collectionName,
@@ -6345,6 +6473,14 @@ var Database = class {
               SUBLEVEL_OPTIONS
             ).get(normalizedPath);
             delOps = existingItem ? [
+              ...makeRefOpsForDocument(
+                normalizedPath,
+                collectionName,
+                collectionReferences,
+                existingItem,
+                "del",
+                level
+              ),
               ...makeIndexOpsForDocument(
                 normalizedPath,
                 collectionName,
@@ -6387,8 +6523,7 @@ var Database = class {
         throw new TinaFetchError(`Error in PUT for ${filepath}`, {
           originalError: error,
           file: filepath,
-          collection: collectionName,
-          stack: error.stack
+          collection: collectionName
         });
       }
     };
@@ -6507,6 +6642,22 @@ var Database = class {
       this.tinaSchema = await createSchema({ schema });
       return this.tinaSchema;
     };
+    this.getCollectionReferences = async (level) => {
+      if (this.collectionReferences) {
+        return this.collectionReferences;
+      }
+      const result = {};
+      const schema = await this.getSchema(level || this.contentLevel);
+      const collections = schema.getCollections();
+      for (const collection of collections) {
+        const collectionReferences = this.tinaSchema.findReferencesFromCollection(
+          collection.name
+        );
+        result[collection.name] = collectionReferences;
+      }
+      this.collectionReferences = result;
+      return result;
+    };
     this.getIndexDefinitions = async (level) => {
       if (!this.collectionIndexDefinitions) {
         await new Promise(async (resolve2, reject) => {
@@ -6516,11 +6667,53 @@ var Database = class {
             const collections = schema.getCollections();
             for (const collection of collections) {
               const indexDefinitions = {
-                [DEFAULT_COLLECTION_SORT_KEY]: { fields: [] }
+                [DEFAULT_COLLECTION_SORT_KEY]: { fields: [] },
                 // provide a default sort key which is the file sort
+                // pseudo-index for the collection's references
+                [REFS_COLLECTIONS_SORT_KEY]: {
+                  fields: [
+                    {
+                      name: REFS_REFERENCE_FIELD,
+                      type: "string",
+                      list: false
+                    },
+                    {
+                      name: REFS_PATH_FIELD,
+                      type: "string",
+                      list: false
+                    }
+                  ]
+                }
               };
-              if (collection.fields) {
-                for (const field of collection.fields) {
+              let fields = [];
+              if (collection.templates) {
+                const templateFieldMap = {};
+                const conflictedFields = /* @__PURE__ */ new Set();
+                for (const template of collection.templates) {
+                  for (const field of template.fields) {
+                    if (!templateFieldMap[field.name]) {
+                      templateFieldMap[field.name] = field;
+                    } else {
+                      if (templateFieldMap[field.name].type !== field.type) {
+                        console.warn(
+                          `Field ${field.name} has conflicting types in templates - skipping index`
+                        );
+                        conflictedFields.add(field.name);
+                      }
+                    }
+                  }
+                }
+                for (const conflictedField in conflictedFields) {
+                  delete templateFieldMap[conflictedField];
+                }
+                for (const field of Object.values(templateFieldMap)) {
+                  fields.push(field);
+                }
+              } else if (collection.fields) {
+                fields = collection.fields;
+              }
+              if (fields) {
+                for (const field of fields) {
                   if (field.indexed !== void 0 && field.indexed === false || field.type === "object") {
                     continue;
                   }
@@ -6668,29 +6861,35 @@ var Database = class {
         }
         startKey = startKey || key || "";
         endKey = key || "";
-        edges = [...edges, { cursor: key, path: filepath }];
+        edges = [...edges, { cursor: key, path: filepath, value: itemRecord }];
       }
       return {
-        edges: await sequential(edges, async (edge) => {
-          try {
-            const node = await hydrator(edge.path);
-            return {
-              node,
-              cursor: btoa(edge.cursor)
-            };
-          } catch (error) {
-            console.log(error);
-            if (error instanceof Error && (!edge.path.includes(".tina/__generated__/_graphql.json") || !edge.path.includes("tina/__generated__/_graphql.json"))) {
-              throw new TinaQueryError({
-                originalError: error,
-                file: edge.path,
-                collection: collection.name,
-                stack: error.stack
-              });
+        edges: await sequential(
+          edges,
+          async ({
+            cursor,
+            path: path7,
+            value
+          }) => {
+            try {
+              const node = await hydrator(path7, value);
+              return {
+                node,
+                cursor: btoa(cursor)
+              };
+            } catch (error) {
+              console.log(error);
+              if (error instanceof Error && (!path7.includes(".tina/__generated__/_graphql.json") || !path7.includes("tina/__generated__/_graphql.json"))) {
+                throw new TinaQueryError({
+                  originalError: error,
+                  file: path7,
+                  collection: collection.name
+                });
+              }
+              throw error;
             }
-            throw error;
           }
-        }),
+        ),
         pageInfo: {
           hasPreviousPage,
           hasNextPage,
@@ -6814,13 +7013,14 @@ var Database = class {
           documentPaths,
           async (collection, documentPaths2) => {
             if (collection && !collection.isDetached) {
-              await _indexContent(
-                this,
-                this.contentLevel,
-                documentPaths2,
+              await _indexContent({
+                database: this,
+                level: this.contentLevel,
+                documentPaths: documentPaths2,
                 enqueueOps,
-                collection
-              );
+                collection,
+                isPartialReindex: true
+              });
             }
           }
         );
@@ -6836,6 +7036,7 @@ var Database = class {
         throw new Error(`No collection found for path: ${filepath}`);
       }
       const indexDefinitions = await this.getIndexDefinitions(this.contentLevel);
+      const collectionReferences = (await this.getCollectionReferences())?.[collection.name];
       const collectionIndexDefinitions = indexDefinitions?.[collection.name];
       let level = this.contentLevel;
       if (collection?.isDetached) {
@@ -6854,6 +7055,14 @@ var Database = class {
           collection.path || ""
         );
         await this.contentLevel.batch([
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection.name,
+            collectionReferences,
+            item,
+            "del",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection.name,
@@ -6918,20 +7127,26 @@ var Database = class {
             );
             const doc = await level2.keys({ limit: 1 }).next();
             if (!doc) {
-              await _indexContent(
-                this,
-                level2,
-                contentPaths,
+              await _indexContent({
+                database: this,
+                level: level2,
+                documentPaths: contentPaths,
                 enqueueOps,
                 collection,
-                userFields.map((field) => [
+                passwordFields: userFields.map((field) => [
                   ...field.path,
                   field.passwordFieldName
                 ])
-              );
+              });
             }
           } else {
-            await _indexContent(this, level, contentPaths, enqueueOps, collection);
+            await _indexContent({
+              database: this,
+              level,
+              documentPaths: contentPaths,
+              enqueueOps,
+              collection
+            });
           }
         }
       );
@@ -7070,7 +7285,15 @@ var hashPasswordValues = async (data, passwordFields) => Promise.all(
   )
 );
 var isGitKeep = (filepath, collection) => filepath.endsWith(`.gitkeep.${collection?.format || "md"}`);
-var _indexContent = async (database, level, documentPaths, enqueueOps, collection, passwordFields) => {
+var _indexContent = async ({
+  database,
+  level,
+  documentPaths,
+  enqueueOps,
+  collection,
+  passwordFields,
+  isPartialReindex
+}) => {
   let collectionIndexDefinitions;
   let collectionPath;
   if (collection) {
@@ -7081,6 +7304,7 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
     }
     collectionPath = collection.path;
   }
+  const collectionReferences = (await database.getCollectionReferences())?.[collection?.name];
   const tinaSchema = await database.getSchema();
   let templateInfo = null;
   if (collection) {
@@ -7102,12 +7326,61 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
         await hashPasswordValues(aliasedData, passwordFields);
       }
       const normalizedPath = normalizePath(filepath);
+      const rootSublevel = level.sublevel(
+        CONTENT_ROOT_PREFIX,
+        SUBLEVEL_OPTIONS
+      );
       const folderKey = folderTreeBuilder.update(
         normalizedPath,
         collectionPath || ""
       );
+      if (isPartialReindex) {
+        const item = await rootSublevel.get(normalizedPath);
+        if (item) {
+          await database.contentLevel.batch([
+            ...makeRefOpsForDocument(
+              normalizedPath,
+              collection?.name,
+              collectionReferences,
+              item,
+              "del",
+              level
+            ),
+            ...makeIndexOpsForDocument(
+              normalizedPath,
+              collection.name,
+              collectionIndexDefinitions,
+              item,
+              "del",
+              level
+            ),
+            // folder indices
+            ...makeIndexOpsForDocument(
+              normalizedPath,
+              `${collection.name}_${folderKey}`,
+              collectionIndexDefinitions,
+              item,
+              "del",
+              level
+            ),
+            {
+              type: "del",
+              key: normalizedPath,
+              sublevel: rootSublevel
+            }
+          ]);
+        }
+      }
       if (!isGitKeep(filepath, collection)) {
         await enqueueOps([
+          ...makeRefOpsForDocument(
+            normalizedPath,
+            collection?.name,
+            collectionReferences,
+            aliasedData,
+            "put",
+            level
+          ),
           ...makeIndexOpsForDocument(
             normalizedPath,
             collection?.name,
@@ -7140,8 +7413,7 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
       throw new TinaFetchError(`Unable to seed ${filepath}`, {
         originalError: error,
         file: filepath,
-        collection: collection?.name,
-        stack: error.stack
+        collection: collection?.name
       });
     }
   });
@@ -7171,6 +7443,7 @@ var _deleteIndexContent = async (database, documentPaths, enqueueOps, collection
       throw new Error(`No indexDefinitions for collection ${collection.name}`);
     }
   }
+  const collectionReferences = (await database.getCollectionReferences())?.[collection?.name];
   const tinaSchema = await database.getSchema();
   let templateInfo = null;
   if (collection) {
@@ -7194,6 +7467,14 @@ var _deleteIndexContent = async (database, documentPaths, enqueueOps, collection
         item
       ) : item;
       await enqueueOps([
+        ...makeRefOpsForDocument(
+          itemKey,
+          collection?.name,
+          collectionReferences,
+          aliasedData,
+          "del",
+          database.contentLevel
+        ),
         ...makeIndexOpsForDocument(
           itemKey,
           collection.name,
@@ -7323,8 +7604,8 @@ import path6 from "path";
 import normalize from "normalize-path";
 var FilesystemBridge = class {
   constructor(rootPath, outputPath) {
-    this.rootPath = rootPath || "";
-    this.outputPath = outputPath || rootPath;
+    this.rootPath = path6.resolve(rootPath);
+    this.outputPath = outputPath ? path6.resolve(outputPath) : this.rootPath;
   }
   async glob(pattern, extension) {
     const basePath = path6.join(this.outputPath, ...pattern.split("/"));
@@ -7336,19 +7617,19 @@ var FilesystemBridge = class {
       }
     );
     const posixRootPath = normalize(this.outputPath);
-    return items.map((item) => {
-      return item.replace(posixRootPath, "").replace(/^\/|\/$/g, "");
-    });
+    return items.map(
+      (item) => item.substring(posixRootPath.length).replace(/^\/|\/$/g, "")
+    );
   }
   async delete(filepath) {
     await fs2.remove(path6.join(this.outputPath, filepath));
   }
   async get(filepath) {
-    return fs2.readFileSync(path6.join(this.outputPath, filepath)).toString();
+    return (await fs2.readFile(path6.join(this.outputPath, filepath))).toString();
   }
   async put(filepath, data, basePathOverride) {
     const basePath = basePathOverride || this.outputPath;
-    await fs2.outputFileSync(path6.join(basePath, filepath), data);
+    await fs2.outputFile(path6.join(basePath, filepath), data);
   }
 };
 var AuditFileSystemBridge = class extends FilesystemBridge {