@tinacms/app 0.0.26 → 0.0.27

package/appFiles/src/App.tsx

@@ -50,9 +50,10 @@ const SetPreview = ({ outputFolder }: { outputFolder: string }) => {
 }
 
 export const TinaAdminWrapper = () => {
+  const schema = { ...config?.schema, config }
   return (
     // @ts-ignore JSX element type 'TinaCMS' does not have any construct or call signatures.ts(2604)
-    <TinaCMS {...config} client={{ apiUrl: __API_URL__ }}>
+    <TinaCMS {...config} schema={schema} client={{ apiUrl: __API_URL__ }}>
       <SetPreview outputFolder={config.build.outputFolder} />
       <TinaAdmin preview={Preview} config={config} />
     </TinaCMS>

package/appFiles/src/fields/rich-text/monaco/mdx.js

@@ -30111,6 +30111,49 @@ function remarkMdx(options = {}) {
   }
 }
 
+// ../../../node_modules/.pnpm/hast-util-whitespace@2.0.0/node_modules/hast-util-whitespace/index.js
+function whitespace(thing) {
+  var value = thing && typeof thing === "object" && thing.type === "text" ? thing.value || "" : thing;
+  return typeof value === "string" && value.replace(/[ \t\n\f\r]/g, "") === "";
+}
+
+// ../../../node_modules/.pnpm/remark-unwrap-images@3.0.1/node_modules/remark-unwrap-images/index.js
+var unknown2 = 1;
+var containsImage = 2;
+var containsOther = 3;
+function remarkUnwrapImages() {
+  return (tree) => {
+    visit(tree, "paragraph", (node, index2, parent) => {
+      if (parent && typeof index2 === "number" && applicable(node) === containsImage) {
+        parent.children.splice(index2, 1, ...node.children);
+        return [SKIP, index2];
+      }
+    });
+  };
+}
+function applicable(node, inLink) {
+  let image2 = unknown2;
+  let index2 = -1;
+  while (++index2 < node.children.length) {
+    const child = node.children[index2];
+    if (whitespace(child)) {
+    } else if (child.type === "image" || child.type === "imageReference") {
+      image2 = containsImage;
+    } else if (!inLink && (child.type === "link" || child.type === "linkReference")) {
+      const linkResult = applicable(child, true);
+      if (linkResult === containsOther) {
+        return containsOther;
+      }
+      if (linkResult === containsImage) {
+        image2 = containsImage;
+      }
+    } else {
+      return containsOther;
+    }
+  }
+  return image2;
+}
+
 // ../../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_freeGlobal.js
 var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
 var freeGlobal_default = freeGlobal;
@@ -30510,6 +30553,8 @@ var remarkToSlate = (root3, field, imageCallback) => {
         return code2(content4);
       case "paragraph":
         return paragraph2(content4);
+      case "image":
+        return image2(content4);
       case "mdxJsxFlowElement":
         return mdxJsxElement(content4, field, imageCallback);
       case "thematicBreak":
@@ -30816,6 +30861,7 @@ var markdownToAst = (value, field) => {
     if (!tree) {
       throw new Error("Error parsing markdown");
     }
+    remarkUnwrapImages({})(tree);
     return tree;
   } catch (e) {
     throw new RichTextParseError(e, e.position);

package/appFiles/src/lib/formify/index.ts

@@ -304,8 +304,28 @@ export const formify = async ({
 const node = G.parse(`
  query Sample {
   ...on Document {
+    _internalValues: _values
     _internalSys: _sys {
+      breadcrumbs
+      basename
+      filename
       path
+      extension
+      relativePath
+      title
+      template
+      collection {
+        name
+        slug
+        label
+        path
+        format
+        matches
+        templates
+        fields
+        __typename
+      }
+      __typename
     }
   }
  }`)

package/appFiles/src/lib/machines/document-machine.ts

@@ -25,7 +25,7 @@ export type FormType = Form<FormValues, FieldType>
 
 export type DataType = Record<string, unknown>
 
-type Data = {
+export type Data = {
   _internalValues: object
   _internalSys: {
     breadcrumbs: string[]
@@ -136,10 +136,14 @@ export const documentMachine =
       services: {
         initializer: async (context) => {
           const tina = context.cms.api.tina as Client
-          const response = await tina.request<{
-            node: Data
-          }>(
-            `query GetNode($id: String!) {
+          let node: Data
+          if (context.data) {
+            node = context.data
+          } else {
+            const response = await tina.request<{
+              node: Data
+            }>(
+              `query GetNode($id: String!) {
         node(id: $id) {
           ...on Document {
             _internalValues: _values
@@ -168,14 +172,16 @@ export const documentMachine =
           }
         }
       }`,
-            { variables: { id: context.id } }
-          )
+              { variables: { id: context.id } }
+            )
+            node = response.node
+          }
           const schema = context.cms.api.tina.schema as TinaSchema
           if (!schema) {
             throw new Error(`Schema must be provided`)
           }
           const collection = schema.getCollection(
-            response.node._internalSys.collection.name
+            node._internalSys.collection.name
           )
           let template: Templateable
           if (collection.templates) {
@@ -183,19 +189,19 @@ export const documentMachine =
               if (typeof template === 'string') {
                 throw new Error(`Global templates not supported`)
               }
-              return template.name === response.node._internalSys.template
+              return template.name === node._internalSys.template
             }) as Templateable
           } else {
             template = collection
           }
           if (!template) {
             throw new Error(
-              `Unable to find template for node ${response.node._internalSys.path}`
+              `Unable to find template for node ${node._internalSys.path}`
             )
           }
           const resolvedForm = resolveForm({
             collection,
-            basename: response.node._internalSys.filename,
+            basename: node._internalSys.filename,
             schema,
             template,
           })
@@ -211,10 +217,10 @@ export const documentMachine =
 
               await context.cms.api.tina.request(mutationString, {
                 variables: {
-                  collection: response.node._internalSys.collection.name,
-                  relativePath: response.node._internalSys.relativePath,
+                  collection: node._internalSys.collection.name,
+                  relativePath: node._internalSys.relativePath,
                   params: schema.transformPayload(
-                    response.node._internalSys.collection.name,
+                    node._internalSys.collection.name,
                     payload
                   ),
                 },
@@ -230,9 +236,8 @@ export const documentMachine =
           const formConfig = {
             id: context.id,
             label:
-              response.node._internalSys.title ||
-              response.node._internalSys.collection.label,
-            initialValues: response.node._internalValues,
+              node._internalSys.title || node._internalSys.collection.label,
+            initialValues: node._internalValues,
             fields: resolvedForm.fields,
             onSubmit,
           }
@@ -250,7 +255,7 @@ export const documentMachine =
             true,
             onSubmit
           )
-          return { form, data: response.node }
+          return { form, data: node }
         },
       },
     }

package/appFiles/src/lib/machines/query-machine.ts

@@ -10,12 +10,11 @@ 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 { assign, ContextFrom, createMachine, spawn } from 'xstate'
+import { assign, createMachine, spawn } from 'xstate'
 import {
   Form,
   TinaCMS,
   NAMER,
-  Template,
   TinaFieldEnriched,
   TinaCollection,
   TinaSchema,
@@ -24,9 +23,8 @@ import {
 } from 'tinacms'
 import * as G from 'graphql'
 import { formify } from '../formify'
-import { documentMachine, FieldType, FormValues } from './document-machine'
+import { Data, documentMachine } from './document-machine'
 import type { ActorRefFrom } from 'xstate'
-import { Blueprint2 } from '../formify'
 
 export type DataType = Record<string, unknown>
 type DocumentInfo = {
@@ -43,18 +41,21 @@ type ContextType = {
   id: null | string
   data: null | DataType
   cms: TinaCMS
-  selectedDocument: string | null
+  documentNode: G.DocumentNode
+  variables: object
   iframe: null | HTMLIFrameElement
+  registerSubForms?: boolean
   formifyCallback: (args: any) => Form
   documentMap: DocumentMap
-  blueprints: Blueprint2[]
+  documents: Data[]
 }
 export const initialContext: Omit<ContextType, 'cms' | 'formifyCallback'> = {
   id: null,
   data: null,
-  selectedDocument: null,
-  blueprints: [],
+  variables: {},
   documentMap: {},
+  documents: [],
+  documentNode: { kind: 'Document', definitions: [] },
   iframe: null,
 }
 export const queryMachine =
@@ -68,7 +69,6 @@ export const queryMachine =
           initializer: {
             data: {
               data: DataType
-              blueprints: Blueprint2[]
             }
           }
           setter: {
@@ -197,9 +197,6 @@ export const queryMachine =
                 REMOVE_QUERY: {
                   target: 'idle',
                 },
-                SELECT_DOCUMENT: {
-                  actions: 'selectDocument',
-                },
                 FIELD_CHANGE: {
                   target: 'pending',
                 },
@@ -214,10 +211,6 @@ export const queryMachine =
       actions: {
         handleError: (_context, event) => console.error(event.data),
         handleMissingDocument: assign((context, event) => {
-          count = count + 1
-          if (count > 50) {
-            throw new Error('infinite loop')
-          }
           if (event.data instanceof QueryError) {
             if (context.documentMap[event.data.id]) {
               // Already exists
@@ -226,6 +219,9 @@ export const queryMachine =
             if (!event.data.id) {
               return context
             }
+            const existingData = context.documents.find(
+              (doc) => doc._internalSys.path === event.data.id
+            )
             const doc = {
               ref: spawn(
                 documentMachine.withContext({
@@ -233,7 +229,7 @@ export const queryMachine =
                   cms: context.cms,
                   formifyCallback: context.formifyCallback,
                   form: null,
-                  data: null,
+                  data: existingData || null,
                 })
               ),
             }
@@ -271,12 +267,6 @@ export const queryMachine =
             ...event.data,
           }
         }),
-        selectDocument: assign((context, event) => {
-          return {
-            ...context,
-            selectedDocument: event.value,
-          }
-        }),
         setIframe: assign((context, event) => {
           return {
             ...context,
@@ -299,41 +289,110 @@ export const queryMachine =
       },
       services: {
         setter: async (context) => {
-          const walk = (obj: unknown, path: string[] = []) => {
-            const accum: Record<string, unknown> = {}
-            if (isScalar(obj)) {
-              return obj
-            }
-            Object.entries(obj as object).map(([key, value]) => {
-              if (Array.isArray(value)) {
-                accum[key] = value.map((item) => walk(item, [...path, key]))
-              } else {
-                const blueprint = context.blueprints.find(
-                  (bp) => bp.path?.join('.') === [...path, key].join('.')
-                )
-                if (blueprint) {
-                  accum[key] = setData(value, blueprint, context)
+          const tinaSchema = context.cms.api.tina.schema as TinaSchema
+          const gqlSchema = context.cms.api.tina.gqlSchema
+          const missingForms: { id: string; skipFormRegister: boolean }[] = []
+          const newData = await G.graphql({
+            schema: gqlSchema,
+            source: G.print(context.documentNode),
+            rootValue: context.data,
+            variableValues: context.variables,
+            fieldResolver: (source, args, _context, info) => {
+              const fieldName = info.fieldName
+              /**
+               * Formify adds `_internalSys` and `_internalValues` to the query
+               * and a user's query might also include `_values` or `_sys`, but
+               * it may not contain all of the info we need, so the actual
+               * source of truth for these values is our alias ones, which are
+               * also guaranteed to include all of the values another `_sys` query
+               * might include
+               */
+              if (fieldName === '_sys') {
+                return source._internalSys
+              }
+              if (fieldName === '_values') {
+                return source._internalValues
+              }
+              if (isNodeType(info.returnType)) {
+                const existingValue = source[fieldName]
+                let skipFormRegister = false
+                if (!existingValue) {
+                  return null
+                }
+                let path: string = ''
+                if (typeof existingValue === 'string') {
+                  // this is a reference value (eg. post.author)
+                  skipFormRegister = true
+                  path = existingValue
+                } else {
+                  path = existingValue._internalSys.path
+                }
+                if (context.documentMap[path]) {
+                  const documentMachine = context.documentMap[path].ref
+                  const documentContext = documentMachine.getSnapshot()?.context
+                  if (!documentContext) {
+                    throw new Error(
+                      `Document not set up properly for id: ${path}`
+                    )
+                  }
+                  const { data, form } = documentContext
+                  const values = form?.values
+                  if (!data || !form || !values) {
+                    throw new Error(
+                      `Document not set up properly for id: ${path}`
+                    )
+                  }
+                  const collectionName = data._internalSys.collection.name
+                  const extraValues = documentContext.data
+                  const formVal = resolveFormValue({
+                    fields: form.fields,
+                    values: values,
+                    tinaSchema,
+                  })
+                  const template = tinaSchema.getTemplateForData({
+                    data: form.values,
+                    collection: tinaSchema.getCollection(collectionName),
+                  })
+                  return {
+                    ...extraValues,
+                    ...formVal,
+                    _sys: data._internalSys,
+                    id: path,
+                    __typename: NAMER.dataTypeName(template.namespace),
+                  }
                 } else {
-                  accum[key] = walk(value, [...path, key])
+                  // TODO: when we support forms in lists, remove this check
+                  // This checks that we're at least 2 levels deep, meaning top-level
+                  // queries list page(relativePath: '...') will be registered, but
+                  // not connection nodes like pageConnection.edges.node
+                  if (info.path?.prev?.prev) {
+                    skipFormRegister = true
+                  }
+                  missingForms.push({ id: path, skipFormRegister })
+                  return null
                 }
               }
-            })
-            return accum
+              return source[fieldName]
+            },
+          })
+          if (missingForms.length > 0) {
+            // Only run this one at a time
+            const missingForm = missingForms[0]
+            throw new QueryError(
+              `Unable to resolve form for initial document`,
+              missingForm.id,
+              missingForm.skipFormRegister
+            )
           }
-          const accum = walk(context.data)
-          return { data: accum }
+          return { data: newData.data }
         },
         initializer: async (context, event) => {
           const tina = context.cms.api.tina as Client
           const schema = await tina.getSchema()
           const documentNode = G.parse(event.value.query)
-          const optimizedQuery = await tina.getOptimizedQuery(documentNode)
-          if (!optimizedQuery) {
-            throw new Error(`Unable to optimize query`)
-          }
-          const { blueprints, formifiedQuery } = await formify({
+          const { formifiedQuery } = await formify({
             schema,
-            optimizedDocumentNode: optimizedQuery,
+            optimizedDocumentNode: documentNode,
           })
           const data = (await context.cms.api.tina.request(
             G.print(formifiedQuery),
@@ -341,17 +400,29 @@ export const queryMachine =
               variables: event.value.variables,
             }
           )) as DataType
+          const documents: Data[] = []
+          // step through every value in the payload to find the documents
+          JSON.stringify(data, (key, value) => {
+            if (value?._internalValues) {
+              documents.push(value)
+            }
+            return value
+          })
           return {
             data,
-            blueprints,
+            documents,
+            variables: event.value.variables,
+            documentNode: formifiedQuery,
             id: event.value.id,
           }
         },
         onChangeCallback: (context) => (callback, _onReceive) => {
           const schema = context.cms.api.tina.schema as TinaSchema
           Object.values(context.documentMap).forEach((documentMachine) => {
-            if (documentMachine.skipFormRegister) {
-              return
+            if (!context.registerSubForms) {
+              if (documentMachine.skipFormRegister) {
+                return
+              }
             }
             const documentContext = documentMachine.ref.getSnapshot()?.context
             const collectionName =
@@ -397,242 +468,121 @@ class QueryError extends Error {
     this.skipFormRegister = skipFormRegister
   }
 }
-let count = 0
-
-// https://github.com/oleics/node-is-scalar/blob/master/index.js
-const withSymbol = typeof Symbol !== 'undefined'
-function isScalar(value: unknown) {
-  const type = typeof value
-  if (type === 'string') return true
-  if (type === 'number') return true
-  if (type === 'boolean') return true
-  if (withSymbol === true && type === 'symbol') return true
 
-  if (value == null) return true
-  if (withSymbol === true && value instanceof Symbol) return true
-  if (value instanceof String) return true
-  if (value instanceof Number) return true
-  if (value instanceof Boolean) return true
-
-  return false
-}
-
-const setData = (
-  data: { [key: string]: unknown },
-  blueprint: Blueprint2,
-  context: ContextFrom<typeof queryMachine>
-) => {
-  if (data?._internalSys) {
-    const id = data._internalSys?.path
-    const doc = context.documentMap[id]
-    const docContext = doc?.ref?.getSnapshot()?.context
-    const form = docContext?.form
-    if (!form) {
-      const skipFormRegiester = (blueprint.path?.length || 0) > 2
-      throw new QueryError(
-        `Unable to resolve form for initial document`,
-        id,
-        skipFormRegiester
-      )
+const isNodeType = (type: G.GraphQLOutputType) => {
+  const namedType = G.getNamedType(type)
+  if (G.isInterfaceType(namedType)) {
+    if (namedType.name === 'Node') {
+      return true
     }
-    const _internalSys = docContext.data?._internalSys
-    if (!_internalSys) {
-      throw new Error(`No system information found for document ${id}`)
+  }
+  if (G.isUnionType(namedType)) {
+    const types = namedType.getTypes()
+    if (
+      types.every((type) => {
+        return type.getInterfaces().some((intfc) => intfc.name === 'Node')
+      })
+    ) {
+      return true
+    }
+  }
+  if (G.isObjectType(namedType)) {
+    if (namedType.getInterfaces().some((intfc) => intfc.name === 'Node')) {
+      return true
     }
-
-    const fields = form.fields
-    const result = resolveForm({
-      id,
-      fields,
-      sys: _internalSys,
-      values: form.values,
-      fieldsToInclude: blueprint.fields,
-      context,
-    })
-    return { ...docContext.data, ...result }
-  } else {
-    // this isn't a node
   }
-  return data
 }
 
-const resolveForm = ({
-  id,
+const resolveFormValue = <T extends Record<string, unknown>>({
   fields,
-  sys,
   values,
-  fieldsToInclude,
-  context,
+  tinaSchema,
 }: {
-  id: string
-  fields: FieldType[]
-  sys: Record<string, unknown>
-  values: FormValues | undefined
-  fieldsToInclude: Blueprint2['fields']
-  context: ContextFrom<typeof queryMachine>
-}) => {
+  fields: TinaFieldEnriched[]
+  values: T
+  tinaSchema: TinaSchema
+}): T & { __typename?: string } => {
   const accum: Record<string, unknown> = {}
-  if (!values) {
-    return accum
-  }
-
-  fieldsToInclude?.forEach((fieldToInclude) => {
-    const field = fields.find((field) => fieldToInclude.name === field.name)
-    if (!field) {
-      if (fieldToInclude.name === 'id') {
-        accum[fieldToInclude.alias] = id
-      } else if (fieldToInclude.name === '_sys') {
-        if (fieldToInclude.alias !== '_internalSys') {
-          const sysAccum: Record<string, unknown> = {}
-          // TODO: loop through these and actually use their alias values
-          fieldToInclude.fields?.forEach((field) => {
-            sysAccum[field.alias] = sys[field.name]
-          })
-          accum[fieldToInclude.alias] = sysAccum
-        }
-      } else if (fieldToInclude.name === '__typename') {
-        // field namespaces are one level deeper than what we need, so grab the first
-        // one and remove the last string on the namespace
-        accum[fieldToInclude.alias] = NAMER.dataTypeName(
-          fields[0].namespace.slice(0, fields[0].namespace.length - 1)
-        )
-      } else if (fieldToInclude.name === '_values') {
-        if (fieldToInclude.alias !== '_internalValues') {
-          accum[fieldToInclude.alias] = values
-        }
-      } else {
-      }
-    } else {
-      const result = resolveField({
-        id,
-        field,
-        sys,
-        value: values[field.name],
-        fieldsToInclude: fieldsToInclude.find(({ name }) => name === field.name)
-          ?.fields,
-        context,
-      })
-      if (result) {
-        accum[fieldToInclude.alias] = result
-      }
+  fields.forEach((field) => {
+    const v = values[field.name]
+    if (!v) {
+      return
     }
+    accum[field.name] = resolveFieldValue({
+      field,
+      value: v,
+      tinaSchema,
+    })
   })
-
-  return accum
+  return accum as T & { __typename?: string }
 }
-const resolveField = ({
-  id,
+const resolveFieldValue = ({
   field,
-  sys,
   value,
-  fieldsToInclude,
-  context,
+  tinaSchema,
 }: {
-  id: string
   field: TinaFieldEnriched
-  sys: Record<string, unknown>
   value: unknown
-  fieldsToInclude: Blueprint2['fields']
-  context: ContextFrom<typeof queryMachine>
+  tinaSchema: TinaSchema
 }) => {
   switch (field.type) {
-    case 'reference':
-      if (!value) {
-        return
-      }
-      if (typeof value === 'string') {
-        const doc = context.documentMap[value]
-        const docContext = doc?.ref?.getSnapshot()?.context
-        const form = docContext?.form
-        if (!form) {
-          throw new QueryError(
-            `Unable to resolve form for document`,
-            value,
-            true
-          )
-        }
-        const _internalSys = docContext.data?._internalSys
-        if (!_internalSys) {
-          throw new Error(`No system information found for document ${id}`)
-        }
-        return resolveForm({
-          id: value,
-          fields: form.fields,
-          sys: _internalSys,
-          values: form.values,
-          fieldsToInclude,
-          context,
-        })
-      }
-      throw new Error(`Unexpected value for type "reference"`)
-    case 'object':
-      if (field.fields) {
-        if (typeof field.fields === 'string') {
-          throw new Error('Global templates not supported')
-        }
-        field.fields
+    case 'object': {
+      if (field.templates) {
         if (field.list) {
           if (Array.isArray(value)) {
             return value.map((item) => {
-              if (typeof field.fields === 'string') {
+              const template = field.templates[item._template]
+              if (typeof template === 'string') {
                 throw new Error('Global templates not supported')
               }
-              return resolveForm({
-                id,
-                fields: field.fields,
-                sys,
-                values: item,
-                fieldsToInclude,
-                context,
-              })
+              return {
+                __typename: NAMER.dataTypeName(template.namespace),
+                ...resolveFormValue({
+                  fields: template.fields,
+                  values: item,
+                  tinaSchema,
+                }),
+              }
             })
           }
         } else {
-          return resolveForm({
-            id,
-            fields: field.fields,
-            sys,
-            values: value,
-            fieldsToInclude,
-            context,
-          })
+          // not implemented
         }
       }
-      if (field.templates) {
-        if (field.list) {
-          if (!value) {
-            return
-          }
-          if (!Array.isArray(value)) {
-            return
-          }
+
+      const templateFields = field.fields
+      if (typeof templateFields === 'string') {
+        throw new Error('Global templates not supported')
+      }
+      if (!templateFields) {
+        throw new Error(`Expected to find sub-fields on field ${field.name}`)
+      }
+      if (field.list) {
+        if (Array.isArray(value)) {
           return value.map((item) => {
-            let t: Template<true>
-            Object.entries(field.templates).forEach(([name, template]) => {
-              if (name === item._template) {
-                if (typeof template === 'string') {
-                  throw new Error('Global templates not supported')
-                }
-                t = template
-              }
-            })
             return {
-              _template: item._template,
-              ...resolveForm({
-                id,
-                fields: t.fields,
-                sys,
+              __typename: NAMER.dataTypeName(field.namespace),
+              ...resolveFormValue({
+                fields: templateFields,
                 values: item,
-                fieldsToInclude,
-                context,
+                tinaSchema,
               }),
             }
           })
-        } else {
-          // not supported yet
+        }
+      } else {
+        return {
+          __typename: NAMER.dataTypeName(field.namespace),
+          ...resolveFormValue({
+            fields: templateFields,
+            values: value as any,
+            tinaSchema,
+          }),
         }
       }
-    default:
+    }
+    default: {
       return value
+    }
   }
 }

package/appFiles/src/preview.tsx

@@ -80,6 +80,8 @@ const QueryMachine = (props: {
       queryMachine.withContext({
         ...initialContext,
         cms,
+        // Enable registration of sub forms
+        // registerSubForms: true,
         // @ts-ignore FIXME: add formifyCallback args to Config type
         formifyCallback: props.formifyCallback,
       }),

package/dist/test-utils.js

@@ -270,8 +270,28 @@ var formify = async ({
 var node = G.parse(`
  query Sample {
   ...on Document {
+    _internalValues: _values
     _internalSys: _sys {
+      breadcrumbs
+      basename
+      filename
       path
+      extension
+      relativePath
+      title
+      template
+      collection {
+        name
+        slug
+        label
+        path
+        format
+        matches
+        templates
+        fields
+        __typename
+      }
+      __typename
     }
   }
  }`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/app",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "main": "dist/index.js",
   "exports": {
     ".": {
@@ -37,8 +37,8 @@
     "@types/react": "17.0.2",
     "@types/react-dom": "17.0.2",
     "@tinacms/scripts": "0.51.3",
-    "tinacms": "0.70.0",
-    "@tinacms/mdx": "0.61.15",
+    "tinacms": "0.70.1",
+    "@tinacms/mdx": "0.61.16",
     "jest": "^27.0.6"
   },
   "dependencies": {