@tinacms/graphql 0.59.8 → 0.59.11

package/dist/index.js

@@ -11398,7 +11398,12 @@ var Builder = class {
           documentsType
         ]
       });
-      return astBuilder.FieldDefinition({ type, name: name2, args, required: true });
+      return astBuilder.FieldDefinition({
+        type,
+        name: name2,
+        args,
+        required: true
+      });
     };
     this.buildMultiCollectionDefinition = async (collections) => {
       const name2 = "getCollections";
@@ -11539,6 +11544,25 @@ var Builder = class {
         type: astBuilder.TYPES.MultiCollectionDocument
       });
     };
+    this.buildDeleteCollectionDocumentMutation = async (collections) => {
+      return astBuilder.FieldDefinition({
+        name: "deleteDocument",
+        args: [
+          astBuilder.InputValueDefinition({
+            name: "collection",
+            required: false,
+            type: astBuilder.TYPES.String
+          }),
+          astBuilder.InputValueDefinition({
+            name: "relativePath",
+            required: true,
+            type: astBuilder.TYPES.String
+          })
+        ],
+        required: true,
+        type: astBuilder.TYPES.MultiCollectionDocument
+      });
+    };
     this.multiCollectionDocumentList = async (collections) => {
       return this._buildMultiCollectionDocumentListDefinition({
         fieldName: "getDocumentList",
@@ -11902,6 +11926,11 @@ var Builder = class {
                 astBuilder.InputValueDefinition({
                   name: "exists",
                   type: astBuilder.TYPES.Boolean
+                }),
+                astBuilder.InputValueDefinition({
+                  name: "in",
+                  type: astBuilder.TYPES.Number,
+                  list: true
                 })
               ]
             })
@@ -11927,6 +11956,11 @@ var Builder = class {
                 astBuilder.InputValueDefinition({
                   name: "exists",
                   type: astBuilder.TYPES.Boolean
+                }),
+                astBuilder.InputValueDefinition({
+                  name: "in",
+                  type: astBuilder.TYPES.String,
+                  list: true
                 })
               ]
             })
@@ -11949,6 +11983,11 @@ var Builder = class {
                 astBuilder.InputValueDefinition({
                   name: "exists",
                   type: astBuilder.TYPES.Boolean
+                }),
+                astBuilder.InputValueDefinition({
+                  name: "in",
+                  type: astBuilder.TYPES.String,
+                  list: true
                 })
               ]
             })
@@ -12086,7 +12125,7 @@ var Builder = class {
             fields: await sequential(collections, async (collection2) => {
               return astBuilder.InputValueDefinition({
                 name: collection2.name,
-                type: await this._filterCollectionDocumentType(collection2)
+                type: NAMER.dataFilterTypeName(collection2.namespace)
               });
             })
           })
@@ -12256,6 +12295,10 @@ var listArgs = [
   astBuilder.InputValueDefinition({
     name: "last",
     type: astBuilder.TYPES.Number
+  }),
+  astBuilder.InputValueDefinition({
+    name: "sort",
+    type: astBuilder.TYPES.String
   })
 ];
 var filterSelections = (arr) => {
@@ -12370,7 +12413,7 @@ var validateField = async (field) => {
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/package.json
 var name = "@tinacms/graphql";
-var version = "0.59.8";
+var version = "0.59.11";
 var main = "dist/index.js";
 var typings = "dist/index.d.ts";
 var files = [
@@ -12416,6 +12459,7 @@ var scripts = {
 };
 var dependencies = {
   "@graphql-tools/relay-operation-optimizer": "^6.4.1",
+  "@tinacms/datalayer": "workspace:*",
   "body-parser": "^1.19.0",
   cors: "^2.8.5",
   dataloader: "^2.0.0",
@@ -12431,6 +12475,7 @@ var dependencies = {
   "graphql-type-json": "^0.3.2",
   "gray-matter": "^4.0.2",
   "js-yaml": "^3.14.0",
+  leveldown: "^6.1.0",
   lodash: "^4.17.20",
   mdast: "^3.0.0",
   "mdast-util-from-markdown": "^1.0.0",
@@ -12438,7 +12483,6 @@ var dependencies = {
   "mdast-util-mdx-expression": "^1.1.0",
   "mdast-util-to-markdown": "^1.2.1",
   "micromark-extension-mdxjs": "^1.0.0",
-  mocha: "^9.1.1",
   "normalize-path": "^3.0.0",
   prettier: "^2.2.1",
   "rehype-format": "^3.1.0",
@@ -12473,7 +12517,6 @@ var devDependencies = {
   "@types/fs-extra": "^9.0.2",
   "@types/jest": "^26.0.4",
   "@types/js-yaml": "^3.12.5",
-  "@types/level": "^6.0.0",
   "@types/lodash": "^4.14.161",
   "@types/lodash.camelcase": "^4.3.6",
   "@types/lodash.upperfirst": "^4.3.6",
@@ -12771,6 +12814,7 @@ var _buildSchema = async (builder, tinaSchema) => {
   queryTypeDefinitionFields.push(await builder.multiCollectionDocument(collections));
   mutationTypeDefinitionFields.push(await builder.addMultiCollectionDocumentMutation());
   mutationTypeDefinitionFields.push(await builder.buildUpdateCollectionDocumentMutation(collections));
+  mutationTypeDefinitionFields.push(await builder.buildDeleteCollectionDocumentMutation(collections));
   mutationTypeDefinitionFields.push(await builder.buildCreateCollectionDocumentMutation(collections));
   queryTypeDefinitionFields.push(await builder.multiCollectionDocumentList(collections));
   queryTypeDefinitionFields.push(await builder.multiCollectionDocumentFields());
@@ -20128,7 +20172,7 @@ var parseMDXInner = (tree, field) => {
     if (!template) {
       if ((0, import_lodash4.isNull)(node.name)) {
       } else {
-        throw new Error(`Found unregistered JSX or HTML: <${node.name}>. Please ensure all structured elements have been registered with your schema.`);
+        throw new Error(`Found unregistered JSX or HTML: <${node.name}>. Please ensure all structured elements have been registered with your schema. https://tina.io/docs/editing/mdx/`);
       }
     }
     if (node.children.length > 0) {
@@ -20357,6 +20401,7 @@ var defaultNodeTypes = {
   delete_mark: plateElements.MARK_STRIKETHROUGH,
   inline_code_mark: plateElements.ELEMENT_CODE_LINE,
   thematic_break: plateElements.ELEMENT_HR,
+  break: "break",
   image: plateElements.ELEMENT_IMAGE
 };
 function remarkToSlate(node) {
@@ -20454,6 +20499,8 @@ function remarkToSlate(node) {
       return __spreadProps(__spreadValues({}, node), {
         children: void 0
       });
+    case "break":
+      return { type: types.break, children: [{ type: "text", text: "" }] };
     default:
       console.log("unknown", node);
       return { type: "text", text: "" };
@@ -22247,6 +22294,10 @@ ${out}
       } catch (e) {
         console.log(e);
       }
+    case "break":
+      return {
+        type: "break"
+      };
     case "text":
       if (node == null ? void 0 : node.code) {
         return {
@@ -22273,7 +22324,102 @@ ${out}
 };
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/resolver/index.ts
-var import_flat = __toModule(require("flat"));
+var import_datalayer = __toModule(require("@tinacms/datalayer"));
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/resolver/filter-utils.ts
+var resolveReferences = async (filter, fields, resolver2) => {
+  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 resolver2(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) {
+          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, resolver2);
+            } else {
+              throw new Error(`Template ${templateName} not found`);
+            }
+          }
+        } else {
+          await resolveReferences(filter[fieldKey], fieldDefinition.fields, resolver2);
+        }
+      }
+    } 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) {
+    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;
+      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: __spreadValues({
+        _type: field.type
+      }, filterNode)
+    });
+  }
+};
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/resolver/index.ts
 var createResolver2 = (args) => {
   return new Resolver(args);
 };
@@ -22302,11 +22448,13 @@ var Resolver = class {
           data: rawData,
           collection
         });
-        const basename = import_path3.default.basename(fullPath);
-        const extension2 = import_path3.default.extname(fullPath);
-        const filename = basename.replace(extension2, "");
+        const {
+          base: basename,
+          ext: extension2,
+          name: filename
+        } = import_path3.default.parse(fullPath);
         const relativePath = fullPath.replace("\\", "/").replace(collection.path, "").replace(/^\/|\/$/g, "");
-        const breadcrumbs = filename.split("/");
+        const breadcrumbs = relativePath.replace(extension2, "").split("/");
         const form = {
           label: collection.label,
           name: basename,
@@ -22346,6 +22494,12 @@ var Resolver = class {
         throw e;
       }
     };
+    this.deleteDocument = async (fullPath) => {
+      if (typeof fullPath !== "string") {
+        throw new Error(`fullPath must be of type string for getDocument request`);
+      }
+      await this.database.delete(fullPath);
+    };
     this.getDocumentFields = async () => {
       try {
         const response = {};
@@ -22470,7 +22624,7 @@ var Resolver = class {
         return this.getDocument(realPath);
       }
       const params = this.buildObjectMutations(args.params[collection.name], collection);
-      await this.database.put(realPath, params);
+      await this.database.put(realPath, params, collection.name);
       return this.getDocument(realPath);
     };
     this.updateResolveDocument = async ({
@@ -22487,7 +22641,7 @@ var Resolver = class {
           case "object":
             if (params2) {
               const values = this.buildFieldMutations(params2, templateInfo.template);
-              await this.database.put(realPath, values);
+              await this.database.put(realPath, values, collection.name);
             }
             break;
           case "union":
@@ -22500,14 +22654,14 @@ var Resolver = class {
                 const values = __spreadProps(__spreadValues({}, this.buildFieldMutations(templateParams, template)), {
                   _template: lastItem(template.namespace)
                 });
-                await this.database.put(realPath, values);
+                await this.database.put(realPath, values, collection.name);
               }
             });
         }
         return this.getDocument(realPath);
       }
       const params = this.buildObjectMutations(isCollectionSpecific ? args.params : args.params[collection.name], collection);
-      await this.database.put(realPath, params);
+      await this.database.put(realPath, params, collection.name);
       return this.getDocument(realPath);
     };
     this.resolveDocument = async ({
@@ -22515,6 +22669,7 @@ var Resolver = class {
       collection: collectionName,
       isMutation,
       isCreation,
+      isDeletion,
       isAddPendingDocument,
       isCollectionSpecific
     }) => {
@@ -22542,6 +22697,14 @@ var Resolver = class {
             isAddPendingDocument
           });
         }
+        if (isDeletion) {
+          if (!alreadyExists) {
+            throw new Error(`Unable to delete document, ${realPath} does not exist`);
+          }
+          const doc = await this.getDocument(realPath);
+          await this.deleteDocument(realPath);
+          return doc;
+        }
         if (alreadyExists === false) {
           throw new Error(`Unable to update document, ${realPath} does not exist`);
         }
@@ -22571,46 +22734,76 @@ var Resolver = class {
       const collection = this.tinaSchema.getCollection(collectionName);
       return this.database.store.glob(collection.path, this.getDocument);
     };
+    this.referenceResolver = async (filter, fieldDefinition) => {
+      const referencedCollection = this.tinaSchema.getCollection(fieldDefinition.collections[0]);
+      if (!referencedCollection) {
+        throw new Error(`Unable to find collection for ${fieldDefinition.collections[0]} querying ${fieldDefinition.name}`);
+      }
+      const sortKeys = Object.keys(filter[fieldDefinition.name][referencedCollection.name]);
+      const resolvedCollectionConnection = await this.resolveCollectionConnection({
+        args: {
+          sort: sortKeys.length === 1 ? sortKeys[0] : void 0,
+          filter: __spreadValues({}, filter[fieldDefinition.name][referencedCollection.name]),
+          first: -1
+        },
+        collection: referencedCollection,
+        hydrator: (path6) => path6
+      });
+      const { edges } = resolvedCollectionConnection;
+      const values = edges.map((edge) => edge.node);
+      return { edges, values };
+    };
     this.resolveCollectionConnection = async ({
       args,
-      lookup
+      collection,
+      hydrator
     }) => {
-      let documents;
-      if (args.filter) {
-        const queries = [];
-        const flattenedArgs = (0, import_flat.default)(args.filter, { delimiter: "#" });
-        Object.entries(flattenedArgs).map(([key2, value]) => {
-          const keys2 = key2.split("#");
-          const maybeTemplateName = keys2[0];
-          const realKey = keys2.slice(0, keys2.length - 1).join("#");
-          const collection = this.tinaSchema.getCollection(lookup.collection);
-          let templateName = collection.name;
-          if (collection.templates) {
-            const template = collection.templates.find((template2) => {
-              if (typeof template2 === "string") {
-                throw new Error("Global templates not yet supported for queries");
+      let edges;
+      let pageInfo;
+      if (args.filter || args.sort) {
+        let conditions;
+        if (args.filter) {
+          if (collection.fields) {
+            conditions = await this.resolveFilterConditions(args.filter, collection.fields, collection.name);
+          } else if (collection.templates) {
+            for (const templateName of Object.keys(args.filter)) {
+              const template = collection.templates.find((template2) => template2.name === templateName);
+              if (template) {
+                conditions = await this.resolveFilterConditions(args.filter[templateName], template.fields, `${collection.name}.${templateName}`);
+              } else {
+                throw new Error(`Error template not found: ${templateName} in collection ${collection.name}`);
               }
-              return template2.name === maybeTemplateName;
-            });
-            if (typeof template === "string") {
-              throw new Error("Global templates not yet supported for queries");
-            }
-            if (template) {
-              templateName = template.name;
             }
           }
-          queries.push(`__attribute__${lookup.collection}#${templateName}#${realKey}#${value}`);
-        });
-        documents = await this.database.query(queries, this.getDocument);
+        }
+        const queryOptions = {
+          filterChain: (0, import_datalayer.makeFilterChain)({
+            conditions: conditions || []
+          }),
+          collection: collection.name,
+          sort: args.sort,
+          first: args.first,
+          last: args.last,
+          before: args.before,
+          after: args.after
+        };
+        const result = await this.database.query(queryOptions, hydrator ? hydrator : this.getDocument);
+        edges = result.edges;
+        pageInfo = result.pageInfo;
       } else {
-        const collection = await this.tinaSchema.getCollection(lookup.collection);
-        documents = await this.database.store.glob(collection.path, this.getDocument);
+        edges = (await this.database.store.glob(collection.path, this.getDocument)).map((document3) => ({
+          node: document3
+        }));
       }
       return {
-        totalCount: documents.length,
-        edges: documents.map((document3) => {
-          return { node: document3 };
-        })
+        totalCount: edges.length,
+        edges,
+        pageInfo: pageInfo || {
+          hasPreviousPage: false,
+          hasNextPage: false,
+          startCursor: "",
+          endCursor: ""
+        }
       };
     };
     this.buildFieldMutations = (fieldParams, template) => {
@@ -22744,6 +22937,7 @@ var Resolver = class {
       } = _d, field = __objRest(_d, [
         "namespace"
       ]);
+      field.parentTypename = NAMER.dataTypeName(namespace.filter((_6, i) => i < namespace.length - 1));
       const extraFields = field.ui || {};
       switch (field.type) {
         case "number":
@@ -22871,6 +23065,27 @@ var Resolver = class {
     this.database = init.database;
     this.tinaSchema = init.tinaSchema;
   }
+  async resolveFilterConditions(filter, fields, collectionName) {
+    const conditions = [];
+    const conditionCollector = (condition) => {
+      if (!condition.filterPath) {
+        throw new Error("Error parsing filter - unable to generate filterPath");
+      }
+      if (!condition.filterExpression) {
+        throw new Error(`Error parsing filter - missing expression for ${condition.filterPath}`);
+      }
+      conditions.push(condition);
+    };
+    await resolveReferences(filter, fields, this.referenceResolver);
+    for (const fieldName of Object.keys(filter)) {
+      const field = fields.find((field2) => field2.name === fieldName);
+      if (!field) {
+        throw new Error(`${fieldName} not found in collection ${collectionName}`);
+      }
+      collectConditionsForField(fieldName, field, filter[fieldName], "", conditionCollector);
+    }
+    return conditions;
+  }
 };
 var resolveDateInput = (value) => {
   const date = new Date(value);
@@ -23015,12 +23230,18 @@ var resolve = async ({
                 isAddPendingDocument: true
               });
             }
-            if (["getDocument", "createDocument", "updateDocument"].includes(info.fieldName)) {
+            if ([
+              "getDocument",
+              "createDocument",
+              "updateDocument",
+              "deleteDocument"
+            ].includes(info.fieldName)) {
               const result2 = await resolver2.resolveDocument({
                 args,
                 collection: args.collection,
                 isMutation,
                 isCreation,
+                isDeletion: info.fieldName === "deleteDocument",
                 isAddPendingDocument: false,
                 isCollectionSpecific: false
               });
@@ -23069,7 +23290,10 @@ var resolve = async ({
             }
             return result;
           case "collectionDocumentList":
-            return resolver2.resolveCollectionConnection({ args, lookup });
+            return resolver2.resolveCollectionConnection({
+              args,
+              collection: tinaSchema.getCollection(lookup.collection)
+            });
           case "unionData":
             return value;
           default:
@@ -23378,7 +23602,7 @@ var parseFile = (content3, format, yupSchema) => {
 };
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/database/index.ts
-var import_lodash7 = __toModule(require("lodash"));
+var import_datalayer2 = __toModule(require("@tinacms/datalayer"));
 var createDatabase = async (config) => {
   return new Database(__spreadProps(__spreadValues({}, config), {
     bridge: config.bridge,
@@ -23390,6 +23614,11 @@ var GENERATED_FOLDER = import_path4.default.join(".tina", "__generated__");
 var Database = class {
   constructor(config) {
     this.config = config;
+    this.collectionForPath = async (filepath) => {
+      const tinaSchema = await this.getSchema();
+      const collection = tinaSchema.schema.collections.find((collection2) => filepath.startsWith(collection2.path));
+      return collection;
+    };
     this.get = async (filepath) => {
       if (SYSTEM_FILES.includes(filepath)) {
         throw new Error(`Unexpected get for config file ${filepath}`);
@@ -23429,27 +23658,39 @@ var Database = class {
     };
     this.addPendingDocument = async (filepath, data) => {
       const { stringifiedFile, payload, keepTemplateKey } = await this.stringifyFile(filepath, data);
+      const collection = await this.collectionForPath(filepath);
+      let collectionIndexDefinitions;
+      if (collection) {
+        const indexDefinitions = await this.getIndexDefinitions();
+        collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
+      }
       if (this.store.supportsSeeding()) {
         await this.bridge.put(filepath, stringifiedFile);
       }
-      await this.store.put(filepath, payload, keepTemplateKey);
+      await this.store.put(filepath, payload, {
+        keepTemplateKey,
+        collection: collection == null ? void 0 : collection.name,
+        indexDefinitions: collectionIndexDefinitions
+      });
     };
-    this.put = async (filepath, data) => {
+    this.put = async (filepath, data, collection) => {
       if (SYSTEM_FILES.includes(filepath)) {
         throw new Error(`Unexpected put for config file ${filepath}`);
       } else {
+        let collectionIndexDefinitions;
+        if (collection) {
+          const indexDefinitions = await this.getIndexDefinitions();
+          collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection];
+        }
         const { stringifiedFile, payload, keepTemplateKey } = await this.stringifyFile(filepath, data);
         if (this.store.supportsSeeding()) {
           await this.bridge.put(filepath, stringifiedFile);
         }
-        if (this.store.supportsIndexing()) {
-          await indexDocument({
-            filepath,
-            data,
-            database: this
-          });
-        }
-        await this.store.put(filepath, payload, keepTemplateKey);
+        await this.store.put(filepath, payload, {
+          keepTemplateKey,
+          collection,
+          indexDefinitions: collectionIndexDefinitions
+        });
       }
       return true;
     };
@@ -23536,6 +23777,56 @@ var Database = class {
       this.tinaSchema = await createSchema({ schema });
       return this.tinaSchema;
     };
+    this.getIndexDefinitions = async () => {
+      if (!this.collectionIndexDefinitions) {
+        await new Promise(async (resolve2, reject) => {
+          try {
+            const schema = await this.getSchema();
+            const collections = schema.getCollections();
+            for (const collection of collections) {
+              const indexDefinitions = {
+                [import_datalayer2.DEFAULT_COLLECTION_SORT_KEY]: { fields: [] }
+              };
+              if (collection.fields) {
+                for (const field of collection.fields) {
+                  if (field.indexed !== void 0 && field.indexed === false || field.type === "object") {
+                    continue;
+                  }
+                  indexDefinitions[field.name] = {
+                    fields: [
+                      {
+                        name: field.name,
+                        type: field.type,
+                        pad: field.type === "number" ? { fillString: "0", maxLength: import_datalayer2.DEFAULT_NUMERIC_LPAD } : void 0
+                      }
+                    ]
+                  };
+                }
+              }
+              if (collection.indexes) {
+                for (const index2 of collection.indexes) {
+                  indexDefinitions[index2.name] = {
+                    fields: index2.fields.map((indexField) => {
+                      var _a;
+                      return {
+                        name: indexField.name,
+                        type: (_a = collection.fields.find((field) => indexField.name === field.name)) == null ? void 0 : _a.type
+                      };
+                    })
+                  };
+                }
+              }
+              this.collectionIndexDefinitions = this.collectionIndexDefinitions || {};
+              this.collectionIndexDefinitions[collection.name] = indexDefinitions;
+            }
+            resolve2();
+          } catch (err) {
+            reject(err);
+          }
+        });
+      }
+      return this.collectionIndexDefinitions;
+    };
     this.documentExists = async (fullpath) => {
       try {
         await this.get(fullpath);
@@ -23544,16 +23835,60 @@ var Database = class {
       }
       return true;
     };
-    this.query = async (queryStrings, hydrator) => {
-      return await this.store.query(queryStrings, hydrator);
+    this.query = async (queryOptions, hydrator) => {
+      const { first, after, last, before, sort, collection, filterChain } = queryOptions;
+      const storeQueryOptions = {
+        sort,
+        collection,
+        filterChain
+      };
+      if (first) {
+        storeQueryOptions.limit = first;
+      } else if (last) {
+        storeQueryOptions.limit = last;
+      } else {
+        storeQueryOptions.limit = 10;
+      }
+      if (after) {
+        storeQueryOptions.gt = (0, import_datalayer2.atob)(after);
+      } else if (before) {
+        storeQueryOptions.lt = (0, import_datalayer2.atob)(before);
+      }
+      if (last) {
+        storeQueryOptions.reverse = true;
+      }
+      const indexDefinitions = await this.getIndexDefinitions();
+      storeQueryOptions.indexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[queryOptions.collection];
+      if (!storeQueryOptions.indexDefinitions) {
+        throw new Error(`No indexDefinitions for collection ${queryOptions.collection}`);
+      }
+      const {
+        edges,
+        pageInfo: { hasPreviousPage, hasNextPage, startCursor, endCursor }
+      } = await this.store.query(storeQueryOptions);
+      return {
+        edges: await sequential(edges, async (edge) => {
+          const node = await hydrator(edge.path);
+          return {
+            node,
+            cursor: (0, import_datalayer2.btoa)(edge.cursor)
+          };
+        }),
+        pageInfo: {
+          hasPreviousPage,
+          hasNextPage,
+          startCursor: (0, import_datalayer2.btoa)(startCursor),
+          endCursor: (0, import_datalayer2.btoa)(endCursor)
+        }
+      };
     };
     this.putConfigFiles = async ({
       graphQLSchema,
       tinaSchema
     }) => {
       if (this.bridge.supportsBuilding()) {
-        await this.bridge.putConfig(import_path4.default.join(GENERATED_FOLDER, `_graphql.json`), JSON.stringify(graphQLSchema, null, 2));
-        await this.bridge.putConfig(import_path4.default.join(GENERATED_FOLDER, `_schema.json`), JSON.stringify(tinaSchema.schema, null, 2));
+        await this.bridge.putConfig(import_path4.default.join(GENERATED_FOLDER, `_graphql.json`), JSON.stringify(graphQLSchema));
+        await this.bridge.putConfig(import_path4.default.join(GENERATED_FOLDER, `_schema.json`), JSON.stringify(tinaSchema.schema));
       }
     };
     this.indexContent = async ({
@@ -23562,7 +23897,7 @@ var Database = class {
     }) => {
       const lookup = JSON.parse(await this.bridge.get(import_path4.default.join(GENERATED_FOLDER, "_lookup.json")));
       if (this.store.supportsSeeding()) {
-        this.store.clear();
+        await this.store.clear();
         await this.store.seed(import_path4.default.join(GENERATED_FOLDER, "_graphql.json"), graphQLSchema);
         await this.store.seed(import_path4.default.join(GENERATED_FOLDER, "_schema.json"), tinaSchema.schema);
         await this.store.seed(import_path4.default.join(GENERATED_FOLDER, "_lookup.json"), lookup);
@@ -23573,14 +23908,39 @@ var Database = class {
         }
       }
     };
+    this.deleteContentByPaths = async (documentPaths) => {
+      const { pathsByCollection, nonCollectionPaths, collections } = await this.partitionPathsByCollection(documentPaths);
+      for (const collection of Object.keys(pathsByCollection)) {
+        await _deleteIndexContent(this, pathsByCollection[collection], collections[collection]);
+      }
+      await _deleteIndexContent(this, nonCollectionPaths, null);
+    };
     this.indexContentByPaths = async (documentPaths) => {
-      await _indexContent(this, documentPaths);
+      const { pathsByCollection, nonCollectionPaths, collections } = await this.partitionPathsByCollection(documentPaths);
+      for (const collection of Object.keys(pathsByCollection)) {
+        await _indexContent(this, pathsByCollection[collection], collections[collection]);
+      }
+      await _indexContent(this, nonCollectionPaths);
+    };
+    this.delete = async (filepath) => {
+      const tinaSchema = await this.getSchema();
+      const collection = tinaSchema.schema.collections.find((collection2) => filepath.startsWith(collection2.path));
+      let collectionIndexDefinitions;
+      if (collection) {
+        const indexDefinitions = await this.getIndexDefinitions();
+        collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
+      }
+      await this.store.delete(filepath, {
+        collection: collection.name,
+        indexDefinitions: collectionIndexDefinitions
+      });
+      await this.bridge.delete(filepath);
     };
     this._indexAllContent = async () => {
       const tinaSchema = await this.getSchema();
       await sequential(tinaSchema.getCollections(), async (collection) => {
         const documentPaths = await this.bridge.glob(collection.path);
-        await _indexContent(this, documentPaths);
+        await _indexContent(this, documentPaths, collection);
       });
     };
     this.addToLookupMap = async (lookup) => {
@@ -23594,147 +23954,75 @@ var Database = class {
       const updatedLookup = __spreadProps(__spreadValues({}, lookupMap), {
         [lookup.type]: lookup
       });
-      await this.bridge.putConfig(lookupPath, JSON.stringify(updatedLookup, null, 2));
+      await this.bridge.putConfig(lookupPath, JSON.stringify(updatedLookup));
     };
     this.bridge = config.bridge;
     this.store = config.store;
   }
+  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 };
+  }
 };
 function hasOwnProperty2(obj, prop) {
   return obj.hasOwnProperty(prop);
 }
-var _indexContent = async (database, documentPaths) => {
+var _indexContent = async (database, documentPaths, collection) => {
+  let seedOptions = void 0;
+  if (collection) {
+    const indexDefinitions = await database.getIndexDefinitions();
+    const collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
+    if (!collectionIndexDefinitions) {
+      throw new Error(`No indexDefinitions for collection ${collection.name}`);
+    }
+    const numIndexes = Object.keys(collectionIndexDefinitions).length;
+    if (numIndexes > 20) {
+      throw new Error(`A maximum of 20 indexes are allowed per field. Currently collection ${collection.name} has ${numIndexes} indexes. Add 'indexed: false' to exclude a field from indexing.`);
+    }
+    seedOptions = {
+      collection: collection.name,
+      indexDefinitions: collectionIndexDefinitions
+    };
+  }
   await sequential(documentPaths, async (filepath) => {
     const dataString = await database.bridge.get(filepath);
     const data = parseFile(dataString, import_path4.default.extname(filepath), (yup3) => yup3.object({}));
     if (database.store.supportsSeeding()) {
-      await database.store.seed(filepath, data);
-    }
-    if (database.store.supportsIndexing()) {
-      return indexDocument({ filepath, data, database });
+      await database.store.seed(filepath, data, seedOptions);
     }
   });
 };
-var indexDocument = async ({
-  filepath,
-  data,
-  database
-}) => {
-  var _a;
-  const schema = await database.getSchema();
-  const collection = await schema.getCollectionByFullPath(filepath);
-  let existingData;
-  try {
-    existingData = await database.get(filepath);
-  } catch (err) {
-    if (((_a = err.extensions) == null ? void 0 : _a["status"]) !== 404) {
-      throw err;
-    }
-  }
-  if (existingData) {
-    const attributesToFilterOut = await _indexCollectable({
-      record: filepath,
-      value: existingData,
-      field: collection,
-      prefix: collection.name,
-      database
-    });
-    await sequential(attributesToFilterOut, async (attribute) => {
-      const records = await database.store.get(attribute) || [];
-      await database.store.put(attribute, records.filter((item) => item !== filepath));
-      return true;
-    });
+var _deleteIndexContent = async (database, documentPaths, collection) => {
+  let deleteOptions = void 0;
+  if (collection) {
+    const indexDefinitions = await database.getIndexDefinitions();
+    const collectionIndexDefinitions = indexDefinitions == null ? void 0 : indexDefinitions[collection.name];
+    if (!collectionIndexDefinitions) {
+      throw new Error(`No indexDefinitions for collection ${collection.name}`);
+    }
+    deleteOptions = {
+      collection: collection.name,
+      indexDefinitions: collectionIndexDefinitions
+    };
   }
-  const attributes = await _indexCollectable({
-    record: filepath,
-    field: collection,
-    value: data,
-    prefix: `${lastItem(collection.namespace)}`,
-    database
-  });
-  await sequential(attributes, async (fieldName) => {
-    const existingRecords = await database.store.get(fieldName) || [];
-    const uniqueItems = [...new Set([...existingRecords, filepath])];
-    await database.store.put(fieldName, uniqueItems);
-  });
-};
-var _indexCollectable = async (_a) => {
-  var _b = _a, {
-    field,
-    value
-  } = _b, rest = __objRest(_b, [
-    "field",
-    "value"
-  ]);
-  let template;
-  let extra = "";
-  if (field.templates) {
-    template = field.templates.find((t) => {
-      if (typeof t === "string") {
-        throw new Error(`Global templates not yet supported`);
-      }
-      if (hasOwnProperty2(value, "_template")) {
-        return t.name === value._template;
-      } else {
-        throw new Error(`Expected value for collectable with multiple templates to have property _template`);
-      }
-    });
-    extra = `#${lastItem(template.namespace)}`;
-  } else {
-    template = field;
-  }
-  const atts = await _indexAttributes({
-    record: rest.record,
-    data: value,
-    prefix: `${rest.prefix}${extra}#${template.name}`,
-    fields: template.fields,
-    database: rest.database
-  });
-  return (0, import_lodash7.flatten)(atts).filter((item) => !(0, import_lodash7.isBoolean)(item));
-};
-var _indexAttributes = async (_a) => {
-  var _b = _a, {
-    data,
-    fields
-  } = _b, rest = __objRest(_b, [
-    "data",
-    "fields"
-  ]);
-  return sequential(fields, async (field) => {
-    const value = data[field.name];
-    if (!value) {
-      return true;
-    }
-    switch (field.type) {
-      case "boolean":
-      case "string":
-      case "number":
-      case "datetime":
-        return _indexAttribute(__spreadValues({ value, field }, rest));
-      case "object":
-        if (field.list) {
-          await sequential(value, async (item) => {
-            return _indexCollectable(__spreadValues({ field, value: item }, rest));
-          });
-        } else {
-          return _indexCollectable(__spreadValues({ field, value }, rest));
-        }
-        return true;
-      case "reference":
-        return _indexAttribute(__spreadValues({ value, field }, rest));
-    }
-    return true;
+  await sequential(documentPaths, async (filepath) => {
+    database.store.delete(filepath, deleteOptions);
   });
 };
-var _indexAttribute = async ({
-  value,
-  prefix,
-  field
-}) => {
-  const stringValue = value.toString().substr(0, 100);
-  const fieldName = `__attribute__${prefix}#${field.name}#${stringValue}`;
-  return fieldName;
-};
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/graphql/src/index.ts
 var buildSchema = async (rootPath, database) => {