@tinacms/graphql 0.63.9 → 0.63.10

package/dist/build.d.ts

@@ -11,7 +11,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import { DocumentNode } from 'graphql';
-import type { TinaSchema } from './schema';
+import { TinaSchema } from '@tinacms/schema-tools';
 import { Database } from './database';
 export declare const buildDotTinaFiles: ({ database, config, flags, buildSDK, }: {
     database: Database;

package/dist/builder/index.d.ts

@@ -12,8 +12,8 @@ limitations under the License.
 */
 import { Database } from '../database';
 import type { ObjectTypeDefinitionNode, InlineFragmentNode, FieldDefinitionNode } from 'graphql';
-import type { TinaCloudCollectionEnriched, Template } from '../types';
-import { TinaSchema } from '../schema';
+import type { TinaCloudCollectionEnriched, Template } from '@tinacms/schema-tools';
+import { TinaSchema } from '@tinacms/schema-tools';
 export declare const createBuilder: ({ database, tinaSchema, }: {
     database: Database;
     tinaSchema: TinaSchema;

package/dist/database/index.d.ts

@@ -12,8 +12,8 @@ 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 { TinaSchema } from '@tinacms/schema-tools';
+import type { TinaCloudSchemaBase } from '@tinacms/schema-tools';
 import type { Bridge } from './bridge';
 declare type IndexStatusEvent = {
     status: 'inprogress' | 'complete' | 'failed';

package/dist/index.d.ts

@@ -10,6 +10,8 @@ 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 type { Store } from '@tinacms/datalayer';
+import type { TinaCloudSchema as TinaCloudSchemaBase, TinaCloudCollection as TinaCloudCollectionBase, TinaCloudTemplateBase as TinaTemplate, TinaFieldBase } from '@tinacms/schema-tools';
 import { buildDotTinaFiles } from './build';
 export { resolve } from './resolve';
 export * from './resolver/error';
@@ -17,19 +19,17 @@ export { createDatabase } from './database';
 export type { QueryOptions } from './database';
 import type { Database } from './database';
 export type { Database } from './database';
-export type { Store } from '@tinacms/datalayer';
 export type { Bridge } from './database/bridge';
 export { sequential, assertShape } from './util';
 export { stringifyFile, parseFile } from './database/util';
-export { createSchema } from './schema';
+export { createSchema } from './schema/createSchema';
 export { buildDotTinaFiles };
 export declare type DummyType = unknown;
 export declare const buildSchema: (rootPath: string, database: Database, flags?: string[]) => Promise<{
     graphQLSchema: import("graphql").DocumentNode;
-    tinaSchema: import("./schema").TinaSchema;
+    tinaSchema: import("@tinacms/schema-tools").TinaSchema;
 }>;
 export declare const getASTSchema: (database: Database) => Promise<import("graphql").GraphQLSchema>;
-import type { TinaCloudSchema as TinaCloudSchemaBase, TinaCloudCollection as TinaCloudCollectionBase, TinaCloudTemplateBase as TinaTemplate, TinaFieldBase } from './types';
 export declare type TinaCloudSchema = TinaCloudSchemaBase<false>;
 export declare type TinaSchema = TinaCloudSchema;
 export declare type TinaCloudCollection = TinaCloudCollectionBase<false>;

package/dist/index.js

@@ -925,6 +925,15 @@ var astBuilder = {
                   selectionSet: {
                     kind: "SelectionSet",
                     selections: [
+                      {
+                        kind: "Field",
+                        name: {
+                          kind: "Name",
+                          value: "cursor"
+                        },
+                        arguments: [],
+                        directives: []
+                      },
                       {
                         kind: "Field",
                         name: {
@@ -2323,6 +2332,9 @@ var filterSelections = (arr) => {
   return arr.filter(Boolean);
 };
 
+// src/schema/createSchema.ts
+var import_schema_tools2 = __toModule(require("@tinacms/schema-tools"));
+
 // src/schema/validate.ts
 var import_lodash2 = __toModule(require("lodash"));
 var yup2 = __toModule(require("yup"));
@@ -2439,7 +2451,7 @@ var validateField = async (field) => {
 
 // package.json
 var name = "@tinacms/graphql";
-var version = "0.63.9";
+var version = "0.63.10";
 var main = "dist/index.js";
 var typings = "dist/index.d.ts";
 var files = [
@@ -2558,56 +2570,7 @@ var package_default = {
   devDependencies
 };
 
-// src/resolver/error.ts
-var TinaGraphQLError = class extends Error {
-  constructor(message, extensions) {
-    super(message);
-    if (!this.name) {
-      Object.defineProperty(this, "name", { value: "TinaGraphQLError" });
-    }
-    this.extensions = __spreadValues({}, extensions);
-  }
-};
-var TinaFetchError = class extends Error {
-  constructor(message, args) {
-    super(message);
-    this.name = "TinaFetchError";
-    this.collection = args.collection;
-    this.stack = args.stack;
-    this.file = args.file;
-    this.originalError = args.originalError;
-  }
-};
-var TinaQueryError = class extends TinaFetchError {
-  constructor(args) {
-    super(`Error querying file ${args.file} from collection ${args.collection}. ${auditMessage(args.includeAuditMessage)}`, args);
-  }
-};
-var TinaParseDocumentError = class extends TinaFetchError {
-  constructor(args) {
-    super(`Error Parsing file ${args.file} from collection ${args.collection}. ${auditMessage(args.includeAuditMessage)}`, args);
-  }
-  toString() {
-    return super.toString() + "\n OriginalError: \n" + this.originalError.toString();
-  }
-};
-var auditMessage = (includeAuditMessage = true) => includeAuditMessage ? `Please run "tinacms audit" or add the --verbose option  for more info` : "";
-var handleFetchErrorError = (e, verbose) => {
-  if (e instanceof Error) {
-    if (e instanceof TinaFetchError) {
-      if (verbose) {
-        console.log(e.toString());
-        console.log(e);
-        console.log(e.stack);
-      }
-    }
-  } else {
-    console.error(e);
-  }
-  throw e;
-};
-
-// src/schema/index.ts
+// src/schema/createSchema.ts
 var createSchema = async ({
   schema,
   flags = []
@@ -2618,7 +2581,7 @@ var createSchema = async ({
   if (flags && flags.length > 0) {
     meta["flags"] = flags;
   }
-  return new TinaSchema(__spreadValues({
+  return new import_schema_tools2.TinaSchema(__spreadValues({
     version: {
       fullVersion: package_default.version,
       major,
@@ -2628,148 +2591,6 @@ var createSchema = async ({
     meta
   }, validSchema));
 };
-var TinaSchema = class {
-  constructor(config) {
-    this.config = config;
-    this.getCollectionsByName = (collectionNames) => {
-      return this.schema.collections.filter((collection) => collectionNames.includes(collection.name));
-    };
-    this.getAllCollectionPaths = () => {
-      const paths = this.getCollections().map((collection) => `${collection.path}${collection.match || ""}`);
-      return paths;
-    };
-    this.getCollection = (collectionName) => {
-      const collection = this.schema.collections.find((collection2) => collection2.name === collectionName);
-      if (!collection) {
-        throw new Error(`Expected to find collection named ${collectionName}`);
-      }
-      const extraFields = {};
-      const templateInfo = this.getTemplatesForCollectable(collection);
-      switch (templateInfo.type) {
-        case "object":
-          extraFields["fields"] = templateInfo.template.fields;
-          break;
-        case "union":
-          extraFields["templates"] = templateInfo.templates;
-          break;
-      }
-      return __spreadProps(__spreadValues(__spreadValues({
-        slug: collection.name
-      }, extraFields), collection), {
-        format: collection.format || "md"
-      });
-    };
-    this.getCollections = () => {
-      return this.schema.collections.map((collection) => this.getCollection(collection.name)) || [];
-    };
-    this.getGlobalTemplate = (templateName) => {
-      var _a;
-      const globalTemplate = (_a = this.schema.templates) == null ? void 0 : _a.find((template) => template.name === templateName);
-      if (!globalTemplate) {
-        throw new Error(`Expected to find global template of name ${templateName}`);
-      }
-      return globalTemplate;
-    };
-    this.getCollectionByFullPath = (filepath) => {
-      const collection = this.getCollections().find((collection2) => {
-        return filepath.replace(/\\/g, "/").startsWith(collection2.path.replace(/\/?$/, "/"));
-      });
-      if (!collection) {
-        throw new Error(`Unable to find collection for file at ${filepath}`);
-      }
-      return collection;
-    };
-    this.getCollectionAndTemplateByFullPath = (filepath, templateName) => {
-      let template;
-      const collection = this.getCollectionByFullPath(filepath);
-      const templates = this.getTemplatesForCollectable(collection);
-      if (templates.type === "union") {
-        if (templateName) {
-          template = templates.templates.find((template2) => lastItem(template2.namespace) === templateName);
-          if (!template) {
-            throw new Error(`Unable to determine template for item at ${filepath}`);
-          }
-        } else {
-          throw new Error(`Unable to determine template for item at ${filepath}, no template name provided for collection with multiple templates`);
-        }
-      }
-      if (templates.type === "object") {
-        template = templates.template;
-      }
-      if (!template) {
-        throw new Error(`Something went wrong while trying to determine template for ${filepath}`);
-      }
-      return { collection, template };
-    };
-    this.getTemplateForData = async ({
-      data,
-      collection
-    }) => {
-      const templateInfo = this.getTemplatesForCollectable(collection);
-      switch (templateInfo.type) {
-        case "object":
-          return templateInfo.template;
-        case "union":
-          assertShape(data, (yup3) => yup3.object({ _template: yup3.string().required() }));
-          const template = templateInfo.templates.find((template2) => template2.namespace[template2.namespace.length - 1] === data._template);
-          if (!template) {
-            throw new TinaGraphQLError(`Expected to find template named '${data._template}' for collection '${lastItem(collection.namespace)}'`, {
-              collection: lastItem(collection.namespace),
-              possibleTemplates: templateInfo.templates.map((template2) => lastItem(template2.namespace)),
-              data
-            });
-          }
-          return template;
-      }
-    };
-    this.isMarkdownCollection = (collectionName) => {
-      const collection = this.getCollection(collectionName);
-      const format = collection.format;
-      if (!format) {
-        return true;
-      }
-      if (["markdown", "md"].includes(format)) {
-        return true;
-      }
-      return false;
-    };
-    this.getTemplatesForCollectable = (collection) => {
-      let extraFields = [];
-      if (collection.references) {
-        extraFields = collection.references;
-      }
-      if (collection.fields) {
-        const template = typeof collection.fields === "string" ? this.getGlobalTemplate(collection.fields) : collection;
-        if (typeof template.fields === "string" || typeof template.fields === "undefined") {
-          throw new Error("Exptected template to have fields but none were found");
-        }
-        return {
-          namespace: collection.namespace,
-          type: "object",
-          template: __spreadProps(__spreadValues({}, template), {
-            fields: [...template.fields, ...extraFields]
-          })
-        };
-      } else {
-        if (collection.templates) {
-          return {
-            namespace: collection.namespace,
-            type: "union",
-            templates: collection.templates.map((templateOrTemplateString) => {
-              const template = typeof templateOrTemplateString === "string" ? this.getGlobalTemplate(templateOrTemplateString) : templateOrTemplateString;
-              return __spreadProps(__spreadValues({}, template), {
-                fields: [...template.fields, ...extraFields]
-              });
-            })
-          };
-        } else {
-          throw new Error(`Expected either fields or templates array to be defined on collection ${collection.namespace.join("_")}`);
-        }
-      }
-    };
-    this.schema = config;
-  }
-};
 
 // src/build.ts
 var import_path = __toModule(require("path"));
@@ -2907,6 +2728,55 @@ var import_isValid = __toModule(require("date-fns/isValid"));
 // src/mdx/index.ts
 var import_mdx = __toModule(require("@tinacms/mdx"));
 
+// src/resolver/error.ts
+var TinaGraphQLError = class extends Error {
+  constructor(message, extensions) {
+    super(message);
+    if (!this.name) {
+      Object.defineProperty(this, "name", { value: "TinaGraphQLError" });
+    }
+    this.extensions = __spreadValues({}, extensions);
+  }
+};
+var TinaFetchError = class extends Error {
+  constructor(message, args) {
+    super(message);
+    this.name = "TinaFetchError";
+    this.collection = args.collection;
+    this.stack = args.stack;
+    this.file = args.file;
+    this.originalError = args.originalError;
+  }
+};
+var TinaQueryError = class extends TinaFetchError {
+  constructor(args) {
+    super(`Error querying file ${args.file} from collection ${args.collection}. ${auditMessage(args.includeAuditMessage)}`, args);
+  }
+};
+var TinaParseDocumentError = class extends TinaFetchError {
+  constructor(args) {
+    super(`Error Parsing file ${args.file} from collection ${args.collection}. ${auditMessage(args.includeAuditMessage)}`, args);
+  }
+  toString() {
+    return super.toString() + "\n OriginalError: \n" + this.originalError.toString();
+  }
+};
+var auditMessage = (includeAuditMessage = true) => includeAuditMessage ? `Please run "tinacms audit" or add the --verbose option  for more info` : "";
+var handleFetchErrorError = (e, verbose) => {
+  if (e instanceof Error) {
+    if (e instanceof TinaFetchError) {
+      if (verbose) {
+        console.log(e.toString());
+        console.log(e);
+        console.log(e.stack);
+      }
+    }
+  } else {
+    console.error(e);
+  }
+  throw e;
+};
+
 // src/resolver/index.ts
 var import_datalayer = __toModule(require("@tinacms/datalayer"));
 
@@ -4086,7 +3956,7 @@ var Database = class {
       } else if (last) {
         storeQueryOptions.limit = last;
       } else {
-        storeQueryOptions.limit = 10;
+        storeQueryOptions.limit = 50;
       }
       if (after) {
         storeQueryOptions.gt = (0, import_datalayer2.atob)(after);

package/dist/mdx/parse.d.ts

@@ -15,9 +15,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 
 */
-import type { Content } from 'mdast';
-import type { GraphQLConfig, RichTypeInner } from '../types';
+import type { RichTypeInner } from '@tinacms/schema-tools';
+import type { GraphQLConfig } from '../types';
 import type { TinaCloudSchemaEnriched } from '@tinacms/schema-tools';
+import type { Content } from 'mdast';
 export declare const parseMDX: (value: string, field: RichTypeInner, graphQLconfig: GraphQLConfig, schema: TinaCloudSchemaEnriched) => {
     type: string;
     children: any;

package/dist/mdx/stringify.d.ts

@@ -15,11 +15,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 
 */
-import type { GraphQLConfig, RichTypeInner } from '../types';
+import type { GraphQLConfig } from '../types';
 import type { TinaCloudSchemaEnriched } from '@tinacms/schema-tools';
 import { plateElements } from './parse';
 import type { Content } from 'mdast';
-export declare const stringifyMDX: (value: unknown, field: RichTypeInner, graphQLconfig: GraphQLConfig, schema: TinaCloudSchemaEnriched) => string;
+export declare const stringifyMDX: (value: unknown, field: any, graphQLconfig: GraphQLConfig, schema: TinaCloudSchemaEnriched) => string;
 export declare const stringify: (node: {
     type: typeof plateElements;
-}, field: RichTypeInner, graphQLconfig: GraphQLConfig, schema: TinaCloudSchemaEnriched) => Content;
+}, field: any, graphQLconfig: GraphQLConfig, schema: TinaCloudSchemaEnriched) => Content;

package/dist/resolve.d.ts

@@ -10,8 +10,8 @@ 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 { Database } from './database';
 import type { GraphQLConfig } from './types';
+import type { Database } from './database';
 export declare const resolve: ({ config, query, variables, database, silenceErrors, verbose, isAudit, }: {
     config?: GraphQLConfig;
     query: string;

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

@@ -10,7 +10,7 @@ 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 { ReferenceTypeInner, TinaFieldInner } from '@tinacms/schema-tools';
 import type { FilterCondition } from '@tinacms/datalayer';
 export declare type ReferenceResolver = (filter: Record<string, object>, fieldDefinition: ReferenceTypeInner) => Promise<{
     edges: {

package/dist/resolver/index.d.ts

@@ -39,6 +39,7 @@ export declare class Resolver {
         label?: string;
         name: string;
         path: string;
+        indexes?: import("@tinacms/schema-tools").TinaIndex[];
         format?: "json" | "md" | "markdown" | "mdx";
         ui?: {
             global?: boolean | {
@@ -86,6 +87,7 @@ export declare class Resolver {
         label?: string;
         name: string;
         path: string;
+        indexes?: import("@tinacms/schema-tools").TinaIndex[];
         format?: "json" | "md" | "markdown" | "mdx";
         ui?: {
             global?: boolean | {

package/dist/schema/createSchema.d.ts

@@ -0,0 +1,17 @@
+/**
+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 { TinaSchema, TinaCloudSchemaBase } from '@tinacms/schema-tools';
+export declare const createSchema: ({ schema, flags, }: {
+    schema: TinaCloudSchemaBase;
+    flags?: string[];
+}) => Promise<TinaSchema>;

package/dist/schema/validate.d.ts

@@ -10,5 +10,5 @@ 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 { TinaCloudSchemaBase } from '../types';
+import { TinaCloudSchemaBase } from '@tinacms/schema-tools';
 export declare const validateSchema: (schema: TinaCloudSchemaBase) => Promise<TinaCloudSchemaBase>;

package/dist/sdkBuilder/index.d.ts

@@ -10,5 +10,5 @@ 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 { TinaSchema } from '../schema';
+import type { TinaSchema } from '@tinacms/schema-tools';
 export declare const buildSKD: (tinaSchema: TinaSchema) => string;

package/dist/spec/setup.d.ts

@@ -10,9 +10,9 @@ 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 { Database } from '../database';
 import type { Store } from '@tinacms/datalayer';
-import type { TinaCloudSchema } from '../types';
+import type { TinaCloudSchema } from '@tinacms/schema-tools';
+import { Database } from '../database';
 export declare const setup: (rootPath: string, schema: TinaCloudSchema<false>, store: Store) => Promise<{
     database: Database;
 }>;

package/dist/types.d.ts

@@ -10,259 +10,6 @@ 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 TinaCloudSchema<WithNamespace extends boolean> {
-    templates?: GlobalTemplate<WithNamespace>[];
-    collections: TinaCloudCollection<WithNamespace>[];
-}
-export declare type TinaCloudSchemaBase = TinaCloudSchema<false>;
-export declare type TinaCloudSchemaEnriched = TinaCloudSchema<true>;
-/**
- * As part of the build process, each node is given a `path: string[]` key
- * to help with namespacing type names, this is added as part of the
- * createTinaSchema step
- */
-export interface TinaCloudSchemaWithNamespace {
-    templates?: GlobalTemplate<true>[];
-    collections: TinaCloudCollection<true>[];
-    namespace: string[];
-}
-export declare type TinaCloudCollection<WithNamespace extends boolean> = CollectionFields<WithNamespace> | CollectionTemplates<WithNamespace>;
-export declare type TinaCloudCollectionBase = TinaCloudCollection<false>;
-export declare type TinaCloudCollectionEnriched = TinaCloudCollection<true>;
-declare type FormatType = 'json' | 'md' | 'markdown' | 'mdx';
-interface BaseCollection {
-    label?: string;
-    name: string;
-    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 {
-    templates: (string | Template<WithNamespace>)[];
-    fields?: undefined;
-}
-export interface CollectionTemplatesWithNamespace<WithNamespace extends boolean> extends BaseCollection {
-    templates: (string | Template<WithNamespace>)[];
-    fields?: undefined;
-    references?: ReferenceType<WithNamespace>[];
-    namespace: WithNamespace extends true ? string[] : undefined;
-}
-declare type CollectionFields<WithNamespace extends boolean> = WithNamespace extends true ? CollectionFieldsWithNamespace<WithNamespace> : CollectionFieldsInner<WithNamespace>;
-export interface CollectionFieldsWithNamespace<WithNamespace extends boolean> extends BaseCollection {
-    fields: string | TinaFieldInner<WithNamespace>[];
-    templates?: undefined;
-    references?: ReferenceType<WithNamespace>[];
-    namespace: string[];
-}
-interface CollectionFieldsInner<WithNamespace extends boolean> extends BaseCollection {
-    fields: string | TinaFieldInner<WithNamespace>[];
-    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;
-    }[];
-};
-export declare type TinaFieldBase = TinaFieldInner<false>;
-export declare type TinaFieldEnriched = TinaFieldInner<true>;
-interface TinaField {
-    name: string;
-    label?: string;
-    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`
-     * will be ignored.
-     */
-    ui?: object;
-}
-declare type ScalarType<WithNamespace extends boolean> = WithNamespace extends true ? ScalarTypeWithNamespace : ScalarTypeInner;
-declare type Option = string | {
-    label: string;
-    value: string;
-};
-declare type ScalarTypeInner = TinaField & TinaScalarField & {
-    options?: Option[];
-};
-declare type ScalarTypeWithNamespace = TinaField & TinaScalarField & {
-    options?: Option[];
-    namespace: string[];
-};
-declare type TinaScalarField = StringField | BooleanField | DateTimeField | NumberField | ImageField;
-declare type StringField = {
-    type: 'string';
-    isBody?: boolean;
-};
-declare type BooleanField = {
-    type: 'boolean';
-};
-declare type NumberField = {
-    type: 'number';
-};
-declare type DateTimeField = {
-    type: 'datetime';
-    dateFormat?: string;
-    timeFormat?: string;
-};
-declare type ImageField = {
-    type: 'image';
-};
-export declare type ReferenceType<WithNamespace extends boolean> = WithNamespace extends true ? ReferenceTypeWithNamespace : ReferenceTypeInner;
-export declare type RichType<WithNamespace extends boolean> = WithNamespace extends true ? RichTypeWithNamespace : RichTypeInner;
-export interface ReferenceTypeInner extends TinaField {
-    type: 'reference';
-    reverseLookup?: {
-        label: string;
-        name: string;
-    };
-    collections: string[];
-}
-export interface ReferenceTypeWithNamespace extends TinaField {
-    type: 'reference';
-    collections: string[];
-    reverseLookup?: {
-        label: string;
-        name: string;
-    };
-    namespace: string[];
-}
-export interface RichTypeWithNamespace extends TinaField {
-    type: 'rich-text';
-    namespace: string[];
-    isBody?: boolean;
-    templates?: (string | (Template<true> & {
-        inline?: boolean;
-    }))[];
-}
-export interface RichTypeInner extends TinaField {
-    type: 'rich-text';
-    isBody?: boolean;
-    templates?: (string | (Template<false> & {
-        inline?: boolean;
-    }))[];
-}
-export declare type ObjectType<WithNamespace extends boolean> = ObjectTemplates<WithNamespace> | ObjectFields<WithNamespace>;
-declare type ObjectTemplates<WithNamespace extends boolean> = WithNamespace extends true ? ObjectTemplatesWithNamespace<WithNamespace> : ObjectTemplatesInner<WithNamespace>;
-interface ObjectTemplatesInner<WithNamespace extends boolean> extends TinaField {
-    type: 'object';
-    required?: false;
-    /**
-     * templates can either be an array of Tina templates or a reference to
-     * global template definition.
-     *
-     * You should use `templates` when your object can be any one of multiple shapes (polymorphic)
-     *
-     * You can only provide one of `fields` or `template`, but not both
-     */
-    templates: (string | Template<WithNamespace>)[];
-    fields?: undefined;
-}
-interface ObjectTemplatesWithNamespace<WithNamespace extends boolean> extends TinaField {
-    type: 'object';
-    required?: false;
-    /**
-     * templates can either be an array of Tina templates or a reference to
-     * global template definition.
-     *
-     * You should use `templates` when your object can be any one of multiple shapes (polymorphic)
-     *
-     * You can only provide one of `fields` or `template`, but not both
-     */
-    templates: (string | Template<WithNamespace>)[];
-    fields?: undefined;
-    namespace: WithNamespace extends true ? string[] : undefined;
-}
-declare type ObjectFields<WithNamespace extends boolean> = WithNamespace extends true ? InnerObjectFieldsWithNamespace<WithNamespace> : InnerObjectFields<WithNamespace>;
-interface InnerObjectFields<WithNamespace extends boolean> extends TinaField {
-    type: 'object';
-    required?: false;
-    /**
-     * fields can either be an array of Tina fields, or a reference to the fields
-     * of a global template definition.
-     *
-     * You can only provide one of `fields` or `templates`, but not both.
-     */
-    fields: string | TinaFieldInner<WithNamespace>[];
-    templates?: undefined;
-}
-interface InnerObjectFieldsWithNamespace<WithNamespace extends boolean> extends TinaField {
-    type: 'object';
-    required?: false;
-    /**
-     * fields can either be an array of Tina fields, or a reference to the fields
-     * of a global template definition.
-     *
-     * You can only provide one of `fields` or `templates`, but not both.
-     */
-    fields: string | TinaFieldInner<WithNamespace>[];
-    templates?: undefined;
-    namespace: WithNamespace extends true ? string[] : undefined;
-}
-/**
- * Global Templates are defined once, and can be used anywhere by referencing the 'name' of the template
- *
- * TODO: ensure we don't permit infite loop with self-references
- */
-export declare type GlobalTemplate<WithNamespace extends boolean> = WithNamespace extends true ? {
-    label: string;
-    name: string;
-    ui?: object;
-    fields: TinaFieldInner<WithNamespace>[];
-    namespace: WithNamespace extends true ? string[] : undefined;
-} : {
-    label: string;
-    name: string;
-    ui?: object;
-    fields: TinaFieldInner<WithNamespace>[];
-};
-export declare type TinaCloudTemplateBase = GlobalTemplate<false>;
-export declare type TinaCloudTemplateEnriched = GlobalTemplate<true>;
-/**
- * Templates allow you to define an object as polymorphic
- */
-export declare type Template<WithNamespace extends boolean> = WithNamespace extends true ? {
-    label: string;
-    name: string;
-    fields: TinaFieldInner<WithNamespace>[];
-    ui?: object;
-    namespace: WithNamespace extends true ? string[] : undefined;
-} : {
-    label: string;
-    name: string;
-    ui?: object;
-    fields: TinaFieldInner<WithNamespace>[];
-};
-export declare type CollectionTemplateableUnion = {
-    namespace: string[];
-    type: 'union';
-    templates: Templateable[];
-};
-export declare type CollectionTemplateableObject = {
-    namespace: string[];
-    type: 'object';
-    required?: false;
-    template: Templateable;
-};
-export declare type CollectionTemplateable = CollectionTemplateableUnion | CollectionTemplateableObject;
-export declare type Collectable = {
-    namespace: string[];
-    templates?: (string | Templateable)[];
-    fields?: string | TinaFieldEnriched[];
-    references?: ReferenceType<true>[];
-};
-export declare type Templateable = {
-    name: string;
-    namespace: string[];
-    fields: TinaFieldEnriched[];
-    ui?: object;
-};
 export declare type GraphQLConfig = {
     useRelativeMedia: true;
 } | {
@@ -270,4 +17,3 @@ export declare type GraphQLConfig = {
     clientId: string;
     assetsHost: string;
 };
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/graphql",
-  "version": "0.63.9",
+  "version": "0.63.10",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -19,9 +19,9 @@
   },
   "dependencies": {
     "@graphql-tools/relay-operation-optimizer": "^6.4.1",
-    "@tinacms/datalayer": "0.2.3",
-    "@tinacms/schema-tools": "0.1.3",
-    "@tinacms/mdx": "0.61.7",
+    "@tinacms/datalayer": "0.2.4",
+    "@tinacms/schema-tools": "0.1.4",
+    "@tinacms/mdx": "0.61.8",
     "body-parser": "^1.19.0",
     "cors": "^2.8.5",
     "dataloader": "^2.0.0",
@@ -71,8 +71,8 @@
     "directory": "packages/tina-graphql"
   },
   "devDependencies": {
-    "@tinacms/datalayer": "0.2.3",
-    "@tinacms/schema-tools": "0.1.3",
+    "@tinacms/datalayer": "0.2.4",
+    "@tinacms/schema-tools": "0.1.4",
     "@tinacms/scripts": "0.51.1",
     "@types/cors": "^2.8.7",
     "@types/estree": "^0.0.50",

package/dist/schema/index.d.ts

@@ -1,78 +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.
-*/
-import type { CollectionTemplateable, Collectable, TinaCloudSchemaEnriched, TinaCloudSchemaBase, Templateable, TinaCloudCollection } from '../types';
-export declare const createSchema: ({ schema, flags, }: {
-    schema: TinaCloudSchemaBase;
-    flags?: string[];
-}) => Promise<TinaSchema>;
-declare type Version = {
-    fullVersion: string;
-    major: string;
-    minor: string;
-    patch: string;
-};
-/**
- * Metadata about how the schema was built
- */
-declare type Meta = {
-    flags?: string[];
-};
-/**
- * TinaSchema is responsible for allowing you to look up certain
- * properties of the user-provided schema with ease.
- */
-export declare class TinaSchema {
-    config: {
-        version?: Version;
-        meta?: Meta;
-    } & TinaCloudSchemaBase;
-    schema: TinaCloudSchemaEnriched;
-    constructor(config: {
-        version?: Version;
-        meta?: Meta;
-    } & TinaCloudSchemaBase);
-    getCollectionsByName: (collectionNames: string[]) => TinaCloudCollection<true>[];
-    getAllCollectionPaths: () => string[];
-    getCollection: (collectionName: string) => TinaCloudCollection<true>;
-    getCollections: () => TinaCloudCollection<true>[];
-    getGlobalTemplate: (templateName: string) => {
-        label: string;
-        name: string;
-        ui?: object;
-        fields: import("../types").TinaFieldInner<true>[];
-        namespace: string[];
-    };
-    getCollectionByFullPath: (filepath: string) => TinaCloudCollection<true>;
-    getCollectionAndTemplateByFullPath: (filepath: string, templateName?: string) => {
-        collection: TinaCloudCollection<true>;
-        template: Templateable;
-    };
-    getTemplateForData: ({ data, collection, }: {
-        data?: unknown;
-        collection: Collectable;
-    }) => Promise<Templateable>;
-    isMarkdownCollection: (collectionName: string) => boolean;
-    /**
-     * Gets the template or templates from the item.
-     * Both `object` fields and collections support
-     * the ability for an object to be polymorphic,
-     * and if it is, we need to build unions, which
-     * are more of a headache for non-polymorphic
-     * needs, so we also need the ability to just
-     * build object types
-     *
-     *
-     */
-    getTemplatesForCollectable: (collection: Collectable) => CollectionTemplateable;
-}
-export {};