@tinacms/graphql 1.3.2 → 1.3.3

package/dist/builder/index.d.ts

@@ -3,7 +3,7 @@
 */
 import { Database } from '../database';
 import type { ObjectTypeDefinitionNode, InlineFragmentNode, FieldDefinitionNode } from 'graphql';
-import type { TinaCloudCollectionEnriched, Template } from '@tinacms/schema-tools';
+import type { Collection, Template } from '@tinacms/schema-tools';
 import { TinaSchema } from '@tinacms/schema-tools';
 export declare const createBuilder: ({ database, tinaSchema, }: {
     database: Database;
@@ -39,7 +39,7 @@ export declare class Builder {
      *
      * @param collections
      */
-    buildCollectionDefinition: (collections: TinaCloudCollectionEnriched[]) => Promise<FieldDefinitionNode>;
+    buildCollectionDefinition: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
     /**
      * ```graphql
      * # ex.
@@ -53,7 +53,7 @@ export declare class Builder {
      *
      * @param collections
      */
-    buildMultiCollectionDefinition: (collections: TinaCloudCollectionEnriched[]) => Promise<FieldDefinitionNode>;
+    buildMultiCollectionDefinition: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
     /**
      * ```graphql
      * # ex.
@@ -79,7 +79,7 @@ export declare class Builder {
      *
      * @param collections
      */
-    multiCollectionDocument: (collections: TinaCloudCollectionEnriched[]) => Promise<FieldDefinitionNode>;
+    multiCollectionDocument: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
     /**
      * ```graphql
      * # ex.
@@ -107,7 +107,7 @@ export declare class Builder {
      *
      * @param collections
      */
-    buildCreateCollectionDocumentMutation: (collections: TinaCloudCollectionEnriched[]) => Promise<FieldDefinitionNode>;
+    buildCreateCollectionDocumentMutation: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
     /**
      * ```graphql
      * # ex.
@@ -121,7 +121,7 @@ export declare class Builder {
      *
      * @param collections
      */
-    buildUpdateCollectionDocumentMutation: (collections: TinaCloudCollectionEnriched[]) => Promise<FieldDefinitionNode>;
+    buildUpdateCollectionDocumentMutation: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
     /**
      * ```graphql
      * # ex.
@@ -135,7 +135,7 @@ export declare class Builder {
      *
      * @param collections
      */
-    buildDeleteCollectionDocumentMutation: (collections: TinaCloudCollectionEnriched[]) => Promise<FieldDefinitionNode>;
+    buildDeleteCollectionDocumentMutation: (collections: Collection<true>[]) => Promise<FieldDefinitionNode>;
     /**
      * ```graphql
      * # ex.
@@ -149,7 +149,7 @@ export declare class Builder {
      *
      * @param collection
      */
-    collectionDocument: (collection: TinaCloudCollectionEnriched) => Promise<FieldDefinitionNode>;
+    collectionDocument: (collection: Collection<true>) => Promise<FieldDefinitionNode>;
     /**
      * Turns a collection into a fragment that gets updated on build. This fragment does not resolve references
      * ```graphql
@@ -164,7 +164,7 @@ export declare class Builder {
      * @public
      * @param collection a Tina Cloud collection
      */
-    collectionFragment: (collection: TinaCloudCollectionEnriched) => Promise<import("graphql").FragmentDefinitionNode>;
+    collectionFragment: (collection: Collection<true>) => Promise<import("graphql").FragmentDefinitionNode>;
     /**
      * Given a collection this function returns its selections set. For example for Post this would return
      *
@@ -195,7 +195,7 @@ export declare class Builder {
      *
      * @param collection
      */
-    updateCollectionDocumentMutation: (collection: TinaCloudCollectionEnriched) => Promise<FieldDefinitionNode>;
+    updateCollectionDocumentMutation: (collection: Collection<true>) => Promise<FieldDefinitionNode>;
     /**
      * ```graphql
      * # ex.
@@ -209,7 +209,7 @@ export declare class Builder {
      *
      * @param collection
      */
-    createCollectionDocumentMutation: (collection: TinaCloudCollectionEnriched) => Promise<FieldDefinitionNode>;
+    createCollectionDocumentMutation: (collection: Collection<true>) => Promise<FieldDefinitionNode>;
     /**
      * ```graphql
      * # ex.
@@ -226,7 +226,7 @@ export declare class Builder {
      *
      * @param collection
      */
-    collectionDocumentList: (collection: TinaCloudCollectionEnriched) => Promise<FieldDefinitionNode>;
+    collectionDocumentList: (collection: Collection<true>) => Promise<FieldDefinitionNode>;
     /**
      * GraphQL type definitions which remain unchanged regardless
      * of the supplied Tina schema. Ex. "node" interface

package/dist/database/alias-utils.d.ts

@@ -0,0 +1,3 @@
+import { Template } from '@tinacms/schema-tools/src';
+export declare const replaceNameOverrides: (template: Template, obj: any) => object;
+export declare const applyNameOverrides: (template: Template, obj: any) => object;

package/dist/database/index.d.ts

@@ -2,7 +2,7 @@
 
 */
 import type { DocumentNode } from 'graphql';
-import type { TinaCloudSchemaBase, TinaSchema } from '@tinacms/schema-tools';
+import type { CollectionTemplateable, TinaCloudCollection, Schema, TinaSchema } from '@tinacms/schema-tools';
 import type { Bridge } from '../database/bridge';
 import { BinaryFilter, IndexDefinition, TernaryFilter } from './datalayer';
 import { Level } from './level';
@@ -59,16 +59,33 @@ export declare class Database {
     }) => Promise<void>;
     put: (filepath: string, data: {
         [key: string]: unknown;
-    }, collection?: string) => Promise<boolean>;
-    stringifyFile: (filepath: string, data: {
+    }, collectionName?: string) => Promise<boolean>;
+    getTemplateDetailsForFile(collection: TinaCloudCollection<true>, data: {
         [key: string]: unknown;
-    }) => Promise<{
-        stringifiedFile: string;
-        payload: {
-            [key: string]: unknown;
+    }): Promise<{
+        template: {
+            label?: string | boolean;
+            name: string;
+            ui?: {
+                itemProps?(item: Record<string, any>): {
+                    key?: string;
+                    label?: string | boolean;
+                };
+                defaultItem?: import("@tinacms/schema-tools").DefaultItem<Record<string, any>>;
+                previewSrc?: string;
+            };
+            fields: ((import("@tinacms/schema-tools").StringField | import("@tinacms/schema-tools").NumberField | import("@tinacms/schema-tools").BooleanField | import("@tinacms/schema-tools").DateTimeField | import("@tinacms/schema-tools").ImageField | import("@tinacms/schema-tools").ReferenceField | import("@tinacms/schema-tools").RichTextField<false> | import("@tinacms/schema-tools").ObjectField<false>) & {})[];
         };
-        keepTemplateKey: boolean;
+        info: CollectionTemplateable;
+    }>;
+    formatBodyOnPayload: (filepath: string, data: {
+        [key: string]: unknown;
+    }) => Promise<{
+        [key: string]: unknown;
     }>;
+    stringifyFile: (filepath: string, payload: {
+        [key: string]: unknown;
+    }, collection: TinaCloudCollection<true>) => Promise<string>;
     /**
      * Clears the internal cache of the tinaSchema and the lookup file. This allows the state to be reset
      */
@@ -77,7 +94,7 @@ export declare class Database {
     getLookup: (returnType: string) => Promise<LookupMapType>;
     getGraphQLSchema: () => Promise<DocumentNode>;
     getGraphQLSchemaFromBridge: () => Promise<DocumentNode>;
-    getTinaSchema: (level?: Level) => Promise<TinaCloudSchemaBase>;
+    getTinaSchema: (level?: Level) => Promise<Schema>;
     getSchema: (level?: Level) => Promise<TinaSchema>;
     getIndexDefinitions: (level?: Level) => Promise<Record<string, Record<string, IndexDefinition>>>;
     documentExists: (fullpath: unknown) => Promise<boolean>;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 /**
 
 */
-import type { TinaCloudSchema as TinaCloudSchemaBase, TinaCloudCollection as TinaCloudCollectionBase, TinaCloudTemplateBase as TinaTemplate, TinaFieldBase } from '@tinacms/schema-tools';
+import type { Schema, Collection, Template as TinaTemplate } from '@tinacms/schema-tools';
 import { buildDotTinaFiles } from './build';
 export { resolve } from './resolve';
 export * from './resolver/error';
@@ -19,12 +19,8 @@ export declare const buildSchema: (rootPath: string, database: Database, flags?:
     tinaSchema: import("@tinacms/schema-tools").TinaSchema;
 }>;
 export declare const getASTSchema: (database: Database) => Promise<import("graphql").GraphQLSchema>;
-export declare type TinaCloudSchema = TinaCloudSchemaBase<false>;
-export declare type TinaSchema = TinaCloudSchema;
-export declare type TinaCloudCollection = TinaCloudCollectionBase<false>;
-export declare type TinaCollection = TinaCloudCollectionBase<false>;
-export declare type TinaField = TinaFieldBase;
-export type { TinaTemplate };
+export declare type TinaSchema = Schema;
+export type { TinaTemplate, Schema, Collection };
 export { FilesystemBridge, AuditFileSystemBridge, } from './database/bridge/filesystem';
 export { IsomorphicBridge } from './database/bridge/isomorphic';
 export type { Bridge } from './database/bridge';

package/dist/index.es.js

@@ -1515,7 +1515,7 @@ var Builder = class {
     };
     this._getCollectionFragmentSelections = async (collection, depth) => {
       const selections = [];
-      if (typeof collection.fields === "object") {
+      if (collection.fields?.length > 0) {
         await sequential(collection.fields, async (x) => {
           const field = await this._buildFieldNodeForFragments(x, depth);
           selections.push(field);
@@ -1539,7 +1539,7 @@ var Builder = class {
         case "rich-text":
           return astBuilder.FieldNodeDefinition(field);
         case "object":
-          if (typeof field.fields === "object") {
+          if (field.fields?.length > 0) {
             const selections2 = [];
             await sequential(field.fields, async (item) => {
               const field2 = await this._buildFieldNodeForFragments(item, depth);
@@ -1552,7 +1552,7 @@ var Builder = class {
                 ...filterSelections(selections2)
               ]
             });
-          } else if (typeof field.templates === "object") {
+          } else if (field.templates?.length > 0) {
             const selections2 = [];
             await sequential(field.templates, async (tem) => {
               if (typeof tem === "object") {
@@ -2387,9 +2387,6 @@ var validateCollection = async (collection) => {
   const validCollection = await collectionSchema.cast(collection);
   if (validCollection.templates) {
     templates = await sequential(validCollection.templates, async (template) => {
-      if (typeof template === "string") {
-        throw new Error(`Global templates are not yet supported`);
-      }
       const fields2 = await sequential(template.fields, async (field) => {
         return validateField(field);
       });
@@ -2422,12 +2419,13 @@ var validateField = async (field) => {
     type: string().oneOf(FIELD_TYPES, (obj) => `'type' must be one of: ${obj.values}, but got '${obj.value}' at ${messageName}`)
   });
   await schema.validate(field);
-  return field;
+  const validField = await schema.cast(field);
+  return validField;
 };
 
 // package.json
 var name = "@tinacms/graphql";
-var version = "1.3.2";
+var version = "1.3.3";
 var main = "dist/index.js";
 var module = "dist/index.es.js";
 var typings = "dist/index.d.ts";
@@ -2793,16 +2791,7 @@ var resolveReferences = async (filter, fields, resolver) => {
         }
       } else if (fieldDefinition.type === "object") {
         if (fieldDefinition.templates) {
-          const globalTemplates = {};
-          for (const template of fieldDefinition.templates) {
-            if (typeof template === "string") {
-              globalTemplates[template] = 1;
-            }
-          }
           for (const templateName of Object.keys(filter[fieldKey])) {
-            if (templateName in globalTemplates) {
-              throw new Error("Global templates not yet supported for queries");
-            }
             const template = fieldDefinition.templates.find((template2) => !(typeof template2 === "string") && template2.name === templateName);
             if (template) {
               await resolveReferences(filter[fieldKey][templateName], template.fields, resolver);
@@ -2830,16 +2819,7 @@ var collectConditionsForChildFields = (filterNode, fields, pathExpression, colle
 };
 var collectConditionsForObjectField = (fieldName, field, filterNode, pathExpression, collectCondition) => {
   if (field.list && field.templates) {
-    const globalTemplates = {};
-    for (const template of field.templates) {
-      if (typeof template === "string") {
-        globalTemplates[template] = 1;
-      }
-    }
     for (const [filterKey, childFilterNode] of Object.entries(filterNode)) {
-      if (filterKey in globalTemplates) {
-        throw new Error("Global templates not yet supported for queries");
-      }
       const template = field.templates.find((template2) => !(typeof template2 === "string") && template2.name === filterKey);
       const jsonPath = `${fieldName}[?(@._template=="${filterKey}")]`;
       const filterPath = pathExpression ? `${pathExpression}.${jsonPath}` : jsonPath;
@@ -3430,7 +3410,7 @@ var Resolver = class {
     };
     this.buildObjectMutations = (fieldValue, field) => {
       if (field.fields) {
-        const objectTemplate = typeof field.fields === "string" ? this.tinaSchema.getGlobalTemplate(field.fields) : field;
+        const objectTemplate = field;
         if (Array.isArray(fieldValue)) {
           return fieldValue.map((item) => this.buildFieldMutations(item, objectTemplate));
         } else {
@@ -3444,9 +3424,6 @@ var Resolver = class {
               throw new Error(`Expected object for template value for field ${field.name}`);
             }
             const templates = field.templates.map((templateOrTemplateName) => {
-              if (typeof templateOrTemplateName === "string") {
-                return this.tinaSchema.getGlobalTemplate(templateOrTemplateName);
-              }
               return templateOrTemplateName;
             });
             const [templateName] = Object.entries(item)[0];
@@ -3464,9 +3441,6 @@ var Resolver = class {
             throw new Error(`Expected object for template value for field ${field.name}`);
           }
           const templates = field.templates.map((templateOrTemplateName) => {
-            if (typeof templateOrTemplateName === "string") {
-              return this.tinaSchema.getGlobalTemplate(templateOrTemplateName);
-            }
             return templateOrTemplateName;
           });
           const [templateName] = Object.entries(fieldValue)[0];
@@ -4176,6 +4150,62 @@ var parseFile = (content, format, yupSchema, markdownParseConfig) => {
 };
 var normalizePath = (filepath) => filepath.replace(/\\/g, "/");
 
+// src/database/alias-utils.ts
+var replaceNameOverrides = (template, obj) => {
+  if (template.list) {
+    return obj.map((item) => {
+      return _replaceNameOverrides(getTemplateForData(template, item).fields, item);
+    });
+  } else {
+    return _replaceNameOverrides(getTemplateForData(template, obj).fields, obj);
+  }
+};
+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 getTemplateKey = (field) => {
+  const DEFAULT_TEMPLATE_KEY = "_template";
+  if (field.templates?.length) {
+    const templateField = field.templates[0]?.fields?.find((field2) => field2.name === DEFAULT_TEMPLATE_KEY);
+    return templateField?.alias || DEFAULT_TEMPLATE_KEY;
+  }
+  return DEFAULT_TEMPLATE_KEY;
+};
+var getTemplateForData = (field, data) => {
+  if (field.templates?.length) {
+    const templateKey = getTemplateKey(field);
+    if (data[templateKey]) {
+      return field.templates.find((template) => template.name === data[templateKey]);
+    }
+  } else {
+    return field;
+  }
+  throw new Error("No template found for field " + field.name);
+};
+var applyNameOverrides = (template, obj) => {
+  if (template.list) {
+    return obj.map((item) => {
+      return _applyNameOverrides(getTemplateForData(template, item).fields, item);
+    });
+  } 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
 var createDatabase = (config) => {
   return new Database({
@@ -4237,8 +4267,9 @@ var Database = class {
     };
     this.addPendingDocument = async (filepath, data) => {
       await this.initLevel();
-      const { stringifiedFile, payload } = await this.stringifyFile(filepath, data);
+      const dataFields = await this.formatBodyOnPayload(filepath, data);
       const collection = await this.collectionForPath(filepath);
+      const stringifiedFile = await this.stringifyFile(filepath, dataFields, collection);
       let collectionIndexDefinitions;
       if (collection) {
         const indexDefinitions = await this.getIndexDefinitions(this.level);
@@ -4249,7 +4280,7 @@ var Database = class {
         await this.bridge.put(normalizedPath, stringifiedFile);
       }
       await this.onPut(normalizedPath, stringifiedFile);
-      const putOps = makeIndexOpsForDocument(normalizedPath, collection?.name, collectionIndexDefinitions, payload, "put", this.level);
+      const putOps = makeIndexOpsForDocument(normalizedPath, collection?.name, collectionIndexDefinitions, dataFields, "put", this.level);
       const existingItem = await this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS).get(normalizedPath);
       const delOps = existingItem ? makeIndexOpsForDocument(normalizedPath, collection?.name, collectionIndexDefinitions, existingItem, "del", this.level) : [];
       const ops = [
@@ -4258,39 +4289,41 @@ var Database = class {
         {
           type: "put",
           key: normalizedPath,
-          value: payload,
+          value: dataFields,
           sublevel: this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS)
         }
       ];
       await this.level.batch(ops);
     };
-    this.put = async (filepath, data, collection) => {
+    this.put = async (filepath, data, collectionName) => {
       await this.initLevel();
       try {
         if (SYSTEM_FILES.includes(filepath)) {
           throw new Error(`Unexpected put for config file ${filepath}`);
         } else {
           let collectionIndexDefinitions;
-          if (collection) {
+          if (collectionName) {
             const indexDefinitions = await this.getIndexDefinitions(this.level);
-            collectionIndexDefinitions = indexDefinitions?.[collection];
+            collectionIndexDefinitions = indexDefinitions?.[collectionName];
           }
           const normalizedPath = normalizePath(filepath);
-          const { stringifiedFile, payload } = await this.stringifyFile(filepath, data);
+          const dataFields = await this.formatBodyOnPayload(filepath, data);
+          const collection = await this.collectionForPath(filepath);
+          const stringifiedFile = await this.stringifyFile(filepath, dataFields, collection);
           if (this.bridge) {
             await this.bridge.put(normalizedPath, stringifiedFile);
           }
           await this.onPut(normalizedPath, stringifiedFile);
-          const putOps = makeIndexOpsForDocument(normalizedPath, collection, collectionIndexDefinitions, payload, "put", this.level);
+          const putOps = makeIndexOpsForDocument(normalizedPath, collectionName, collectionIndexDefinitions, dataFields, "put", this.level);
           const existingItem = await this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS).get(normalizedPath);
-          const delOps = existingItem ? makeIndexOpsForDocument(normalizedPath, collection, collectionIndexDefinitions, existingItem, "del", this.level) : [];
+          const delOps = existingItem ? makeIndexOpsForDocument(normalizedPath, collectionName, collectionIndexDefinitions, existingItem, "del", this.level) : [];
           const ops = [
             ...delOps,
             ...putOps,
             {
               type: "put",
               key: normalizedPath,
-              value: payload,
+              value: dataFields,
               sublevel: this.level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS)
             }
           ];
@@ -4301,66 +4334,52 @@ var Database = class {
         throw new TinaFetchError(`Error in PUT for ${filepath}`, {
           originalError: error,
           file: filepath,
-          collection,
+          collection: collectionName,
           stack: error.stack
         });
       }
     };
-    this.stringifyFile = async (filepath, data) => {
-      if (SYSTEM_FILES.includes(filepath)) {
-        throw new Error(`Unexpected put for config file ${filepath}`);
-      } else {
-        const tinaSchema = await this.getSchema(this.level);
-        const collection = tinaSchema.getCollectionByFullPath(filepath);
-        const templateInfo = await tinaSchema.getTemplatesForCollectable(collection);
-        let template;
-        if (templateInfo.type === "object") {
-          template = templateInfo.template;
-        }
-        if (templateInfo.type === "union") {
-          if (hasOwnProperty(data, "_template")) {
-            template = templateInfo.templates.find((t) => lastItem(t.namespace) === data._template);
-          } else {
-            throw new Error(`Expected _template to be provided for document in an ambiguous collection`);
+    this.formatBodyOnPayload = async (filepath, data) => {
+      const tinaSchema = await this.getSchema(this.level);
+      const collection = tinaSchema.getCollectionByFullPath(filepath);
+      const { template } = await this.getTemplateDetailsForFile(collection, data);
+      const bodyField = template.fields.find((field) => {
+        if (field.type === "string" || field.type === "rich-text") {
+          if (field.isBody) {
+            return true;
           }
         }
-        if (!template) {
-          throw new Error(`Unable to determine template`);
-        }
-        const field = template.fields.find((field2) => {
-          if (field2.type === "string" || field2.type === "rich-text") {
-            if (field2.isBody) {
-              return true;
-            }
+        return false;
+      });
+      let payload = {};
+      if (["md", "mdx"].includes(collection.format) && bodyField) {
+        Object.entries(data).forEach(([key, value]) => {
+          if (key !== bodyField.name) {
+            payload[key] = value;
           }
-          return false;
         });
-        let payload = {};
-        if (["md", "mdx"].includes(collection.format) && field) {
-          Object.entries(data).forEach(([key, value]) => {
-            if (key !== field.name) {
-              payload[key] = value;
-            }
-          });
-          payload["$_body"] = data[field.name];
-        } else {
-          payload = data;
-        }
-        const extension = path3.extname(filepath);
-        const stringifiedFile = stringifyFile(payload, extension, templateInfo.type === "union", {
-          frontmatterFormat: collection?.frontmatterFormat,
-          frontmatterDelimiters: collection?.frontmatterDelimiters
-        });
-        return {
-          stringifiedFile,
-          payload,
-          keepTemplateKey: templateInfo.type === "union"
-        };
+        payload["$_body"] = data[bodyField.name];
+      } else {
+        payload = data;
       }
+      return payload;
+    };
+    this.stringifyFile = async (filepath, payload, collection) => {
+      const templateDetails = await this.getTemplateDetailsForFile(collection, payload);
+      const writeTemplateKey = templateDetails.info.type === "union";
+      const aliasedData = applyNameOverrides(templateDetails.template, payload);
+      const extension = path3.extname(filepath);
+      const stringifiedFile = stringifyFile(aliasedData, extension, writeTemplateKey, {
+        frontmatterFormat: collection?.frontmatterFormat,
+        frontmatterDelimiters: collection?.frontmatterDelimiters
+      });
+      return stringifiedFile;
     };
     this.flush = async (filepath) => {
       const data = await this.get(filepath);
-      const { stringifiedFile } = await this.stringifyFile(filepath, data);
+      const dataFields = await this.formatBodyOnPayload(filepath, data);
+      const collection = await this.collectionForPath(filepath);
+      const stringifiedFile = await this.stringifyFile(filepath, dataFields, collection);
       return stringifiedFile;
     };
     this.getLookup = async (returnType) => {
@@ -4751,6 +4770,28 @@ var Database = class {
       throw new GraphQLError4("Error initializing LevelDB instance");
     }
   }
+  async getTemplateDetailsForFile(collection, data) {
+    const tinaSchema = await this.getSchema();
+    const templateInfo = await tinaSchema.getTemplatesForCollectable(collection);
+    let template;
+    if (templateInfo.type === "object") {
+      template = templateInfo.template;
+    }
+    if (templateInfo.type === "union") {
+      if (hasOwnProperty(data, "_template")) {
+        template = templateInfo.templates.find((t) => lastItem(t.namespace) === data._template);
+      } else {
+        throw new Error(`Expected _template to be provided for document in an ambiguous collection`);
+      }
+    }
+    if (!template) {
+      throw new Error(`Unable to determine template`);
+    }
+    return {
+      template,
+      info: templateInfo
+    };
+  }
   clearCache() {
     this.tinaSchema = null;
     this._lookup = null;
@@ -4778,6 +4819,11 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
       throw new Error(`No indexDefinitions for collection ${collection.name}`);
     }
   }
+  const tinaSchema = await database.getSchema();
+  let templateInfo = null;
+  if (collection) {
+    templateInfo = await tinaSchema.getTemplatesForCollectable(collection);
+  }
   await sequential(documentPaths, async (filepath) => {
     try {
       const dataString = await database.bridge.get(normalizePath(filepath));
@@ -4786,12 +4832,13 @@ var _indexContent = async (database, level, documentPaths, enqueueOps, collectio
         frontmatterFormat: collection?.frontmatterFormat
       });
       const normalizedPath = normalizePath(filepath);
+      const aliasedData = templateInfo ? replaceNameOverrides(getTemplateForFile(templateInfo, data), data) : data;
       await enqueueOps([
-        ...makeIndexOpsForDocument(normalizedPath, collection?.name, collectionIndexDefinitions, data, "put", level),
+        ...makeIndexOpsForDocument(normalizedPath, collection?.name, collectionIndexDefinitions, aliasedData, "put", level),
         {
           type: "put",
           key: normalizedPath,
-          value: data,
+          value: aliasedData,
           sublevel: level.sublevel(CONTENT_ROOT_PREFIX, SUBLEVEL_OPTIONS)
         }
       ]);
@@ -4826,6 +4873,19 @@ var _deleteIndexContent = async (database, documentPaths, enequeueOps, collectio
     }
   });
 };
+var getTemplateForFile = (templateInfo, data) => {
+  if (templateInfo.type === "object") {
+    return templateInfo.template;
+  }
+  if (templateInfo.type === "union") {
+    if (hasOwnProperty(data, "_template")) {
+      return templateInfo.templates.find((t) => lastItem(t.namespace) === data._template);
+    } else {
+      throw new Error(`Expected _template to be provided for document in an ambiguous collection`);
+    }
+  }
+  throw new Error(`Unable to determine template`);
+};
 
 // src/level/tinaLevel.ts
 import { ManyLevelGuest } from "many-level";