@tinacms/graphql 0.0.0-202222211116 → 0.0.0-2022222183246

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # tina-graphql
 
+## 0.0.0-2022222183246
+
+### Patch Changes
+
+- e7b27ba3b: Fix issue where un-normalized rich-text fields which send `null` values to the server on save would cause a parsing error
+- 11d55f441: Add experimental useGraphQLForms hook
+- e8043d510: Enable query filtering, pagination, sorting
+- Updated dependencies [e8043d510]
+  - @tinacms/datalayer@0.0.0-2022222183246
+
 ## 0.59.7
 
 ### Patch Changes

package/dist/database/index.d.ts

@@ -10,21 +10,32 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
+import type { BinaryFilter, IndexDefinition, Store, TernaryFilter } from '@tinacms/datalayer';
 import type { DocumentNode } from 'graphql';
 import type { TinaSchema } from '../schema';
-import type { TinaCloudSchemaBase } from '../types';
-import type { Store } from './store';
+import type { TinaCloudSchemaBase, CollectionFieldsWithNamespace, CollectionTemplatesWithNamespace } from '../types';
 import type { Bridge } from './bridge';
 declare type CreateDatabase = {
     bridge: Bridge;
     store: Store;
 };
 export declare const createDatabase: (config: CreateDatabase) => Promise<Database>;
+/** Options for {@link Database.query} **/
+export declare type QueryOptions = {
+    collection: string;
+    filterChain?: (BinaryFilter | TernaryFilter)[];
+    sort?: string;
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+};
 export declare class Database {
     config: CreateDatabase;
     bridge: Bridge;
     store: Store;
     private tinaSchema;
+    private collectionIndexDefinitions;
     private _lookup;
     private _graphql;
     private _tinaSchema;
@@ -51,8 +62,20 @@ export declare class Database {
     getGraphQLSchemaFromBridge: () => Promise<DocumentNode>;
     getTinaSchema: () => Promise<TinaCloudSchemaBase>;
     getSchema: () => Promise<TinaSchema>;
+    getIndexDefinitions: () => Promise<Record<string, Record<string, IndexDefinition>>>;
     documentExists: (fullpath: unknown) => Promise<boolean>;
-    query: (queryStrings: string[], hydrator: any) => Promise<object[]>;
+    query: (queryOptions: QueryOptions, hydrator: any) => Promise<{
+        edges: {
+            node: any;
+            cursor: string;
+        }[];
+        pageInfo: {
+            hasPreviousPage: boolean;
+            hasNextPage: boolean;
+            startCursor: string;
+            endCursor: string;
+        };
+    }>;
     putConfigFiles: ({ graphQLSchema, tinaSchema, }: {
         graphQLSchema: DocumentNode;
         tinaSchema: TinaSchema;
@@ -61,7 +84,7 @@ export declare class Database {
         graphQLSchema: DocumentNode;
         tinaSchema: TinaSchema;
     }) => Promise<void>;
-    indexContentByPaths: (documentPaths: string[]) => Promise<void>;
+    indexContentByPaths: (documentPaths: string[], collection: CollectionFieldsWithNamespace<true> | CollectionTemplatesWithNamespace<true>) => Promise<void>;
     _indexAllContent: () => Promise<void>;
     addToLookupMap: (lookup: LookupMapType) => Promise<void>;
 }

package/dist/index.d.ts

@@ -13,9 +13,10 @@ limitations under the License.
 export { indexDB } from './build';
 export { resolve } from './resolve';
 export { createDatabase } from './database';
+export type { QueryOptions } from './database';
 import type { Database } from './database';
 export type { Database } from './database';
-export type { Store } from './database/store';
+export type { Store } from '@tinacms/datalayer';
 export type { Bridge } from './database/bridge';
 export { sequential, assertShape } from './util';
 export { stringifyFile, parseFile } from './database/util';

package/dist/index.js

@@ -11902,6 +11902,11 @@ var Builder = class {
                 astBuilder.InputValueDefinition({
                   name: "exists",
                   type: astBuilder.TYPES.Boolean
+                }),
+                astBuilder.InputValueDefinition({
+                  name: "in",
+                  type: astBuilder.TYPES.Number,
+                  list: true
                 })
               ]
             })
@@ -11927,6 +11932,11 @@ var Builder = class {
                 astBuilder.InputValueDefinition({
                   name: "exists",
                   type: astBuilder.TYPES.Boolean
+                }),
+                astBuilder.InputValueDefinition({
+                  name: "in",
+                  type: astBuilder.TYPES.String,
+                  list: true
                 })
               ]
             })
@@ -11949,6 +11959,11 @@ var Builder = class {
                 astBuilder.InputValueDefinition({
                   name: "exists",
                   type: astBuilder.TYPES.Boolean
+                }),
+                astBuilder.InputValueDefinition({
+                  name: "in",
+                  type: astBuilder.TYPES.String,
+                  list: true
                 })
               ]
             })
@@ -12256,6 +12271,10 @@ var listArgs = [
   astBuilder.InputValueDefinition({
     name: "last",
     type: astBuilder.TYPES.Number
+  }),
+  astBuilder.InputValueDefinition({
+    name: "sort",
+    type: astBuilder.TYPES.String
   })
 ];
 var filterSelections = (arr) => {
@@ -12416,6 +12435,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 +12451,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 +12459,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 +12493,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",
@@ -21895,6 +21914,9 @@ var allChildrenEmpty = (children) => {
   return false;
 };
 var stringifyChildren = (children, field) => {
+  if (!children) {
+    return [];
+  }
   return children.map((child) => stringify(child, field)).filter(Boolean);
 };
 var stringify = (node, field) => {
@@ -22270,7 +22292,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);
 };
@@ -22568,46 +22685,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) => {
@@ -22868,6 +23015,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);
@@ -23066,7 +23234,7 @@ 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:
@@ -23375,7 +23543,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,
@@ -23429,7 +23597,7 @@ var Database = class {
       if (this.store.supportsSeeding()) {
         await this.bridge.put(filepath, stringifiedFile);
       }
-      await this.store.put(filepath, payload, keepTemplateKey);
+      await this.store.put(filepath, payload, { keepTemplateKey });
     };
     this.put = async (filepath, data) => {
       if (SYSTEM_FILES.includes(filepath)) {
@@ -23439,14 +23607,7 @@ var Database = class {
         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 });
       }
       return true;
     };
@@ -23533,6 +23694,55 @@ 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
+                      }
+                    ]
+                  };
+                }
+              }
+              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);
@@ -23541,8 +23751,50 @@ 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,
@@ -23570,14 +23822,14 @@ var Database = class {
         }
       }
     };
-    this.indexContentByPaths = async (documentPaths) => {
-      await _indexContent(this, documentPaths);
+    this.indexContentByPaths = async (documentPaths, collection) => {
+      await _indexContent(this, documentPaths, collection);
     };
     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) => {
@@ -23600,138 +23852,24 @@ var Database = class {
 function hasOwnProperty2(obj, prop) {
   return obj.hasOwnProperty(prop);
 }
-var _indexContent = async (database, documentPaths) => {
+var _indexContent = async (database, documentPaths, 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.`);
+  }
   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 });
-    }
-  });
-};
-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;
-    });
-  }
-  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;
+      await database.store.seed(filepath, data, { collection: collection.name, indexDefinitions: collectionIndexDefinitions });
     }
-    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;
   });
 };
-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) => {

package/dist/resolver/filter-utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ Copyright 2021 Forestry.io Holdings, Inc.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+import { ReferenceTypeInner, TinaFieldInner } from '../types';
+import type { FilterCondition } from '@tinacms/datalayer';
+export declare type ReferenceResolver = (filter: Record<string, object>, fieldDefinition: ReferenceTypeInner) => Promise<{
+    edges: {
+        node: any;
+    }[];
+    values: any[];
+}>;
+export declare const resolveReferences: (filter: any, fields: TinaFieldInner<false>[], resolver: ReferenceResolver) => Promise<void>;
+export declare const collectConditionsForField: (fieldName: string, field: TinaFieldInner<false>, filterNode: Record<string, object>, pathExpression: string, collectCondition: (condition: FilterCondition) => void) => void;

package/dist/resolver/index.d.ts

@@ -11,8 +11,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import { TinaSchema } from '../schema';
-import { Database, CollectionDocumentListLookup } from '../database';
-import type { Collectable, TinaCloudCollection } from '../types';
+import { Database } from '../database';
+import type { Collectable, ReferenceTypeWithNamespace, TinaCloudCollection } from '../types';
+import { TinaFieldInner } from '../types';
 interface ResolverConfig {
     database: Database;
     tinaSchema: TinaSchema;
@@ -28,32 +29,34 @@ export declare class Resolver {
     tinaSchema: TinaSchema;
     constructor(init: ResolverConfig);
     resolveCollection: (collectionName: string, hasDocuments?: boolean) => Promise<{
-        fields: string | import("../types").TinaFieldInner<true>[];
+        fields: string | TinaFieldInner<true>[];
         templates?: undefined;
-        references?: import("../types").ReferenceTypeWithNamespace[];
+        references?: ReferenceTypeWithNamespace[];
         namespace: string[];
         label?: string;
         name: string;
         path: string;
         format?: "json" | "md" | "markdown" | "mdx";
         match?: string;
+        indexes?: import("../types").TinaIndex[];
         documents: {};
     } | {
         templates: (string | {
             label: string;
             name: string;
-            fields: import("../types").TinaFieldInner<true>[];
+            fields: TinaFieldInner<true>[];
             ui?: object;
             namespace: string[];
         })[];
         fields?: undefined;
-        references?: import("../types").ReferenceTypeWithNamespace[];
+        references?: ReferenceTypeWithNamespace[];
         namespace: string[];
         label?: string;
         name: string;
         path: string;
         format?: "json" | "md" | "markdown" | "mdx";
         match?: string;
+        indexes?: import("../types").TinaIndex[];
         documents: {};
     }>;
     getDocument: (fullPath: unknown) => Promise<{
@@ -243,12 +246,16 @@ export declare class Resolver {
         }[];
     }>;
     getDocumentsForCollection: (collectionName: string) => Promise<string[]>;
-    resolveCollectionConnection: ({ args, lookup, }: {
-        args: Record<string, Record<string, object>>;
-        lookup: CollectionDocumentListLookup;
+    private referenceResolver;
+    private resolveFilterConditions;
+    resolveCollectionConnection: ({ args, collection, hydrator, }: {
+        args: Record<string, Record<string, object> | string | number>;
+        collection: TinaCloudCollection<true>;
+        hydrator?: (string: any) => any;
     }) => Promise<{
         totalCount: any;
         edges: any;
+        pageInfo: any;
     }>;
     private buildFieldMutations;
     private resolveFieldData;

package/dist/spec/setup.d.ts

@@ -11,7 +11,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import { Database } from '../database';
-import type { Store } from '../database/store';
+import type { Store } from '@tinacms/datalayer';
 import type { TinaCloudSchema } from '../types';
 export declare const setup: (rootPath: string, schema: TinaCloudSchema<false>, store: Store) => Promise<{
     database: Database;

package/dist/types.d.ts

@@ -36,6 +36,7 @@ interface BaseCollection {
     path: string;
     format?: FormatType;
     match?: string;
+    indexes?: TinaIndex[];
 }
 declare type CollectionTemplates<WithNamespace extends boolean> = WithNamespace extends true ? CollectionTemplatesWithNamespace<WithNamespace> : CollectionTemplatesInner<WithNamespace>;
 interface CollectionTemplatesInner<WithNamespace extends boolean> extends BaseCollection {
@@ -60,6 +61,13 @@ interface CollectionFieldsInner<WithNamespace extends boolean> extends BaseColle
     templates?: undefined;
 }
 export declare type TinaFieldInner<WithNamespace extends boolean> = ScalarType<WithNamespace> | ObjectType<WithNamespace> | ReferenceType<WithNamespace> | RichType<WithNamespace>;
+export declare type TinaIndex = {
+    name: string;
+    fields: {
+        name: string;
+        default?: string | number | boolean;
+    }[];
+};
 export declare type TinaFieldBase = TinaFieldInner<false>;
 export declare type TinaFieldEnriched = TinaFieldInner<true>;
 interface TinaField {
@@ -68,6 +76,7 @@ interface TinaField {
     description?: string;
     required?: boolean;
     list?: boolean;
+    indexed?: boolean;
     /**
      * Any items passed to the UI field will be passed to the underlying field.
      * NOTE: only serializable values are supported, so functions like `validate`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/graphql",
-  "version": "0.0.0-202222211116",
+  "version": "0.0.0-2022222183246",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -46,6 +46,7 @@
   },
   "dependencies": {
     "@graphql-tools/relay-operation-optimizer": "^6.4.1",
+    "@tinacms/datalayer": "0.0.0-2022222183246",
     "body-parser": "^1.19.0",
     "cors": "^2.8.5",
     "dataloader": "^2.0.0",
@@ -61,6 +62,7 @@
     "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",
@@ -68,7 +70,6 @@
     "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",
@@ -95,15 +96,14 @@
     "directory": "packages/tina-graphql"
   },
   "devDependencies": {
-    "@tinacms/datalayer": "0.0.0-202222211116",
-    "@tinacms/scripts": "0.0.0-202222211116",
+    "@tinacms/datalayer": "0.0.0-2022222183246",
+    "@tinacms/scripts": "0.50.7",
     "@types/cors": "^2.8.7",
     "@types/estree": "^0.0.50",
     "@types/express": "^4.17.8",
     "@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",

package/dist/database/store/index.d.ts

@@ -1,72 +0,0 @@
-/**
-Copyright 2021 Forestry.io Holdings, Inc.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-export interface Store {
-    glob(pattern: string, hydrator?: (fullPath: string) => Promise<object>): Promise<string[]>;
-    get<T extends object>(filepath: string): Promise<T>;
-    clear(): void;
-    /**
-     *
-     * @param queryStrings
-     * Queries are currently structured as prefixed keys where that last portion
-     * of the key is the value provided by the query
-     * ```graphql
-     * {
-     *   getPostsList(filter: {
-     *     title: {
-     *       eq: "Hello, World"
-     *     }
-     *   }) {
-     *      ...
-     *   }
-     * }
-     * ```
-     * Would equate to a query string of:
-     * ```
-     * __attribute__#posts#posts#title#Hello, World
-     * ```
-     * This can be used by a data store as a secondary index of sorts
-     *
-     * It's important to note that for now each query string acts as an "AND" clause,
-     * meaning the resulting records need to be present in _each_ query string.
-     *
-     * @param hydrator
-     * hydrator is an optional callback, which may be useful depending on the storage mechanism.
-     * For example, the in-memory storage only stores the path to its records as its value,
-     * but in something like DynamoDB the query strings may be used to look up the full record,
-     * meaning there's no need to "hydrate" the return value
-     */
-    query(queryStrings: string[], hydrator?: (fullPath: string) => Promise<object>): Promise<object[]>;
-    /**
-     * In this context, seeding is the act of putting records and indexing data into an ephemeral
-     * storage layer for use during the GraphQL runtime. What might seem suprising is that some stores
-     * don't support seeding, this is because they're behaving more like a "bridge" (GithubStore and FilesystemStore).
-     * Currently they're acting as a way to swap out true data-layer behavior with a backwards-compatible
-     * "store". In the future, all stores should be able to query and seed data.
-     *
-     * At this time it seems that it would never make sense to be able to "query" without "seed"-ing, and
-     * there'd be no value in "seeding" without "query"-ing.
-     */
-    seed(filepath: string, data: object, options?: {
-        includeTemplate?: boolean;
-    }): Promise<void>;
-    supportsSeeding(): boolean;
-    /**
-     * Whether this store supports the ability to index data.
-     * Indexing data requires writing arbitrary keys/values to
-     * the external service, so is not advisable to use for
-     * something like Github, which would write commits to the
-     * user's repo.
-     */
-    supportsIndexing(): boolean;
-    put(filepath: string, data: object, keepTemplateKey?: boolean): Promise<void>;
-}