@tinacms/graphql 0.0.0-20218161139 → 0.0.0-2021816214827

package/CHANGELOG.md

@@ -1,10 +1,10 @@
 # tina-graphql
 
-## 0.0.0-20218161139
+## 0.0.0-2021816214827
 
-### Patch Changes
+### Minor Changes
 
-- Set it
+- f3bddeb4a: Added new warning messages for list UI that we do not support by default
 
 ## 0.54.3
 

package/dist/index.js

@@ -489,7 +489,6 @@ var astBuilder = {
     ID: "ID",
     SystemInfo: "SystemInfo",
     Boolean: "Boolean",
-    JSON: "JSON",
     Node: "Node",
     PageInfo: "PageInfo",
     Connection: "Connection",
@@ -1154,12 +1153,6 @@ var Builder = class {
             list: field.list,
             type: yield this._updateCollectionDocumentMutationType(field)
           });
-        case "rich-text":
-          return astBuilder.InputValueDefinition({
-            name: field.name,
-            list: field.list,
-            type: astBuilder.TYPES.JSON
-          });
         case "reference":
           return astBuilder.InputValueDefinition({
             name: field.name,
@@ -1268,13 +1261,6 @@ Visit https://tina.io/docs/errors/ui-not-supported/ for more information
             required: field.required,
             type: yield this._buildObjectOrUnionData(this.tinaSchema.getTemplatesForCollectable(field))
           });
-        case "rich-text":
-          return astBuilder.FieldDefinition({
-            name: field.name,
-            list: field.list,
-            required: field.required,
-            type: astBuilder.TYPES.JSON
-          });
         case "reference":
           const name = NAMER.documentTypeName(field.namespace);
           if (field.list) {
@@ -1546,636 +1532,6 @@ var import_graphql3 = __toModule(require("graphql"));
 var import_lodash5 = __toModule(require("lodash"));
 var import_path2 = __toModule(require("path"));
 var import_isValid = __toModule(require("date-fns/isValid"));
-
-// ../graphql/src/primitives/mdx/parse.ts
-var import_unified = __toModule(require("unified"));
-var import_remark_parse = __toModule(require("remark-parse"));
-var import_remark_mdx = __toModule(require("remark-mdx"));
-var import_unist_util_visit = __toModule(require("unist-util-visit"));
-var parseMDX = (value, field) => {
-  const tree = (0, import_unified.unified)().use(import_remark_parse.default).use(import_remark_mdx.default).parse(value);
-  return parseMDXInner(tree, field);
-};
-var parseMDXInner = (tree, field) => {
-  (0, import_unist_util_visit.visit)(tree, (node) => {
-    delete node.position;
-  });
-  (0, import_unist_util_visit.visit)(tree, ["mdxJsxFlowElement", "mdxJsxTextElement"], (node) => {
-    var _a;
-    let props = {};
-    if (!node.name) {
-      props = parseMDXInner({ type: "root", children: node.children }, field);
-    }
-    const template = (_a = field.templates) == null ? void 0 : _a.find((template2) => {
-      const templateName = typeof template2 === "string" ? template2 : template2.name;
-      return templateName === node.name;
-    });
-    if (node.children.length > 0) {
-      node.attributes.push({
-        value: node.children,
-        name: "children",
-        type: "mdxJsxAttribute"
-      });
-    }
-    node.children = null;
-    node.attributes.forEach((attribute) => {
-      if (attribute.type === "mdxJsxAttribute") {
-        if (typeof template === "string") {
-          throw new Error("Global templates not yet supported");
-        }
-        if (!template) {
-        } else {
-          const field2 = template.fields.find((field3) => field3.name === attribute.name);
-          if (!field2) {
-            throw new Error(`Unknown property '${attribute.name}' for embedded structure '${node.name}'`);
-          }
-          parseField(attribute, field2, props);
-        }
-      } else {
-        console.log(`Not sure what this is, type: ${attribute.type}`);
-      }
-    });
-    delete node.attributes;
-    node.props = props;
-  });
-  const slateTree = tree.children.map(remarkToSlate);
-  return { type: "root", children: slateTree };
-};
-var parseField = (attribute, field, props) => {
-  var _a, _b;
-  switch (field.type) {
-    case "boolean":
-    case "datetime":
-    case "image":
-    case "number":
-    case "string":
-      if (field.list) {
-        if (((_a = attribute.value) == null ? void 0 : _a.type) === "mdxJsxAttributeValueExpression") {
-          attribute.value.data.estree.body.forEach((item) => {
-            if (item.type === "ExpressionStatement") {
-              if (item.expression.type === "ArrayExpression") {
-                props[field.name] = item.expression.elements.map((element) => {
-                  if (element.type === "Literal") {
-                    return element.value;
-                  } else {
-                    throw new Error(`Only literals are supported for array expressions`);
-                  }
-                });
-              }
-            }
-          });
-        }
-      } else {
-        if (attribute.type === "Property") {
-          if (attribute.value.type === "Literal") {
-            props[attribute.key.name] = attribute.value.value;
-          }
-        } else if (((_b = attribute.value) == null ? void 0 : _b.type) === "mdxJsxAttributeValueExpression") {
-          attribute.value.data.estree.body.forEach((item) => {
-            if (item.type === "ExpressionStatement") {
-              if (item.expression.type === "Literal") {
-                props[field.name] = item.expression.value;
-              }
-              if (item.expression.type === "ArrayExpression") {
-                throw new Error(`Unexpected array expression for non-list field ${field.name}`);
-              }
-              if (item.expression.type === "TemplateLiteral") {
-                throw new Error(`Template literals are not yet supported`);
-              }
-            }
-          });
-        } else {
-          props[field.name] = attribute.value;
-        }
-      }
-      break;
-    case "object":
-      if (attribute.type === "mdxJsxAttribute") {
-        if (attribute.value.type === "mdxJsxAttributeValueExpression") {
-          attribute.value.data.estree.body.forEach((item) => {
-            if (item.type === "ExpressionStatement") {
-              if (item.expression.type === "ObjectExpression") {
-                const objectProps = {};
-                item.expression.properties.forEach((property) => {
-                  if (property.key.type !== "Identifier") {
-                    throw new Error(`Unexptected key type ${property.key.type}`);
-                  }
-                  if (property.value.type !== "Literal") {
-                    throw new Error(`Unexptected value type ${property.value.type}`);
-                  }
-                  if (field.fields) {
-                    if (typeof field.fields === "string") {
-                      throw new Error(`Global fields not supported at this time`);
-                    }
-                    field.fields.forEach((field2) => {
-                      parseField(property, field2, objectProps);
-                    });
-                  }
-                });
-                props[field.name] = objectProps;
-              } else if (item.expression.type === "ArrayExpression") {
-                const objectArrayProps = [];
-                item.expression.elements.forEach((element) => {
-                  if (element.type === "ObjectExpression") {
-                    const objectProps = {};
-                    element.properties.forEach((property) => {
-                      if (property.key.type !== "Identifier") {
-                        throw new Error(`Unexptected key type ${property.key.type}`);
-                      }
-                      if (property.value.type !== "Literal") {
-                        throw new Error(`Unexptected value type ${property.value.type}`);
-                      }
-                      if (field.fields) {
-                        if (typeof field.fields === "string") {
-                          throw new Error(`Global fields not supported at this time`);
-                        }
-                        field.fields.forEach((field2) => {
-                          parseField(property, field2, objectProps);
-                        });
-                      }
-                      if (field.templates) {
-                        field.templates.forEach((fieldTemplate) => {
-                          if (typeof fieldTemplate === "string") {
-                            throw new Error(`Global fields not supported at this time`);
-                          }
-                          fieldTemplate.fields.forEach((field2) => {
-                            parseField(property, field2, objectProps);
-                          });
-                        });
-                      }
-                    });
-                    objectArrayProps.push(objectProps);
-                  } else {
-                    throw new Error(`Unexpected expression type ${element.type}`);
-                  }
-                  props[field.name] = objectArrayProps;
-                });
-              } else {
-                throw new Error("Only object expressions are supported");
-              }
-            }
-          });
-        }
-      }
-      break;
-    case "rich-text":
-      if (attribute.value) {
-        if (field.name === "children") {
-          if (Array.isArray(attribute.value)) {
-            props[field.name] = parseMDXInner({ type: "root", children: attribute.value }, field);
-          } else {
-            throw Error(`Expected an array of MDX strings for rich-text field with the special name 'children'`);
-          }
-        } else {
-          try {
-            const mdx2 = parseMDX(attribute.value.value, field);
-            props[field.name] = mdx2.children[0].props;
-          } catch (e) {
-            console.log(e);
-          }
-        }
-      } else {
-        console.log("nothing", field.name, import_remark_mdx.default);
-      }
-      break;
-  }
-};
-var defaultNodeTypes = {
-  paragraph: "paragraph",
-  block_quote: "block_quote",
-  code_block: "code_block",
-  link: "link",
-  ul_list: "ul_list",
-  ol_list: "ol_list",
-  listItem: "list_item",
-  heading: {
-    1: "heading_one",
-    2: "heading_two",
-    3: "heading_three",
-    4: "heading_four",
-    5: "heading_five",
-    6: "heading_six"
-  },
-  emphasis_mark: "italic",
-  strong_mark: "bold",
-  delete_mark: "strikeThrough",
-  inline_code_mark: "code",
-  thematic_break: "thematic_break",
-  image: "image"
-};
-function remarkToSlate(node) {
-  const types = __spreadProps(__spreadValues({}, defaultNodeTypes), {
-    heading: __spreadValues({}, defaultNodeTypes.heading)
-  });
-  switch (node.type) {
-    case "heading":
-      return {
-        type: types.heading[node.depth || 1],
-        children: node.children.map(remarkToSlate)
-      };
-    case "list":
-      return {
-        type: node.ordered ? types.ol_list : types.ul_list,
-        children: node.children.map(remarkToSlate)
-      };
-    case "listItem":
-      return {
-        type: types.listItem,
-        children: node.children.map(remarkToSlate)
-      };
-    case "paragraph":
-      return {
-        type: types.paragraph,
-        children: node.children.map(remarkToSlate)
-      };
-    case "link":
-      return {
-        type: types.link,
-        link: node.url,
-        children: node.children.map(remarkToSlate)
-      };
-    case "image":
-      return {
-        type: types.image,
-        link: node.url,
-        caption: node.alt
-      };
-    case "blockquote":
-      return {
-        type: types.block_quote,
-        children: node.children.map(remarkToSlate)
-      };
-    case "code":
-      return {
-        type: types.code_block,
-        language: node.lang,
-        children: [{ type: "text", text: node.value }]
-      };
-    case "emphasis":
-      return __spreadValues(__spreadValues({
-        [types.emphasis_mark]: true
-      }, forceLeafNode(node.children)), persistLeafFormats(node.children));
-    case "strong":
-      return __spreadValues(__spreadValues({
-        [types.strong_mark]: true
-      }, forceLeafNode(node.children)), persistLeafFormats(node.children));
-    case "delete":
-      return __spreadValues(__spreadValues({
-        [types.delete_mark]: true
-      }, forceLeafNode(node.children)), persistLeafFormats(node.children));
-    case "inlineCode":
-      return {
-        [types.inline_code_mark]: true,
-        text: node.value
-      };
-    case "thematicBreak":
-      return {
-        type: types.thematic_break,
-        children: [{ type: "text", text: "" }]
-      };
-    case "text":
-      return { type: "text", text: node.value || "" };
-    case "mdxJsxFlowElement":
-    case "mdxJsxTextElement":
-      return __spreadProps(__spreadValues({}, node), {
-        children: void 0
-      });
-    default:
-      console.log("unknown", node);
-      return { type: "text", text: "" };
-  }
-}
-var forceLeafNode = (children) => {
-  const extraProps = {};
-  const text = [];
-  children.forEach((k) => {
-    switch (k.type) {
-      case "text":
-        return text.push(k.value || "");
-      case "strong":
-      case "emphasis":
-      case "code":
-        const format = { strong: "bold", em: "italic", code: "code" };
-        extraProps[format[k.type]] = true;
-        return k.children.forEach((item) => {
-          text.push(item.value);
-        });
-      default:
-        throw new Error(`Not sure, this should be flattened to the same node`);
-    }
-  });
-  return __spreadValues({
-    type: "text",
-    text: text.join("")
-  }, extraProps);
-};
-function persistLeafFormats(children) {
-  return children.reduce((acc, node) => {
-    Object.keys(node).forEach(function(key) {
-      if (key === "children" || key === "type" || key === "text")
-        return;
-      acc[key] = node[key];
-    });
-    return acc;
-  }, {});
-}
-
-// ../graphql/src/primitives/mdx/stringify.ts
-var import_mdast_util_to_markdown = __toModule(require("mdast-util-to-markdown"));
-var import_mdast_util_mdx = __toModule(require("mdast-util-mdx"));
-var stringifyMDX = (value, field) => {
-  const slateTree = value.children;
-  try {
-    const tree = slateTree.map((item) => stringify(item, field));
-    const out = (0, import_mdast_util_to_markdown.toMarkdown)({
-      type: "root",
-      children: tree
-    }, {
-      extensions: [import_mdast_util_mdx.mdxToMarkdown]
-    });
-    return out.replace(/"/g, `"`);
-  } catch (e) {
-    console.log(e);
-  }
-};
-var stringify = (node, field) => {
-  var _a;
-  if (!node.type) {
-    return {
-      type: "text",
-      value: node.text || ""
-    };
-  }
-  switch (node.type) {
-    case "heading_one":
-      return {
-        type: "heading",
-        depth: 1,
-        children: node.children.map((child) => stringify(child, field))
-      };
-    case "heading_two":
-      return {
-        type: "heading",
-        depth: 2,
-        children: node.children.map((child) => stringify(child, field))
-      };
-    case "heading_three":
-      return {
-        type: "heading",
-        depth: 3,
-        children: node.children.map((child) => stringify(child, field))
-      };
-    case "heading_four":
-      return {
-        type: "heading",
-        depth: 4,
-        children: node.children.map((child) => stringify(child, field))
-      };
-    case "heading_five":
-      return {
-        type: "heading",
-        depth: 5,
-        children: node.children.map((child) => stringify(child, field))
-      };
-    case "heading_six":
-      return {
-        type: "heading",
-        depth: 6,
-        children: node.children.map((child) => stringify(child, field))
-      };
-    case "paragraph":
-      return {
-        type: "paragraph",
-        children: node.children.map((child) => stringify(child, field))
-      };
-    case "link":
-      return {
-        type: "link",
-        url: node.link,
-        children: node.children.map((child) => stringify(child, field))
-      };
-    case "mdxJsxTextElement":
-    case "mdxJsxFlowElement":
-      try {
-        let children = [];
-        const atts = [];
-        const template = (_a = field.templates) == null ? void 0 : _a.find((fieldTemplate) => {
-          if (typeof fieldTemplate === "string") {
-            throw new Error(`Global templates not yet supported`);
-          } else {
-            return fieldTemplate.name === node.name;
-          }
-        });
-        if (typeof template === "string") {
-          throw new Error(`Global templates not yet supported`);
-        }
-        Object.entries(node.props).map(([key, value]) => {
-          if (template.fields) {
-            const field2 = template.fields.find((field3) => field3.name === key);
-            if (!field2) {
-              throw new Error(`Unknown field for key ${key}`);
-            }
-            switch (field2.type) {
-              case "boolean":
-              case "datetime":
-              case "image":
-              case "number":
-              case "string":
-                if (field2.list) {
-                  const v = {
-                    type: "mdxJsxAttributeValueExpression",
-                    value: `[${value.map((item) => {
-                      switch (field2.type) {
-                        case "boolean":
-                        case "number":
-                          return `${item}`;
-                        case "image":
-                        case "datetime":
-                        case "string":
-                          return `"${item}"`;
-                      }
-                    })}]`
-                  };
-                  atts.push({ type: "mdxJsxAttribute", name: key, value: v });
-                } else {
-                  atts.push({
-                    type: "mdxJsxAttribute",
-                    name: key,
-                    value: `${value}`
-                  });
-                }
-                break;
-              case "object":
-                if (field2.list) {
-                  const values = [];
-                  value.forEach((item) => {
-                    if (field2.fields) {
-                      const v = {};
-                      if (typeof field2.fields === "string") {
-                        throw new Error(`Global templates not yet supported for rich text`);
-                      }
-                      field2.fields.forEach((field3) => {
-                        const fieldValue = item[field3.name];
-                        if (fieldValue) {
-                          switch (field3.type) {
-                            case "boolean":
-                            case "number":
-                              v[field3.name] = `${fieldValue}`;
-                              break;
-                            case "image":
-                            case "datetime":
-                            case "string":
-                              v[field3.name] = `"${fieldValue}"`;
-                              break;
-                          }
-                        }
-                        values.push(v);
-                      });
-                    } else {
-                      value.forEach((item2) => {
-                        const [itemTemplateName, itemValues] = Object.entries(item2)[0];
-                        const template2 = field2.templates.find((template3) => {
-                          const templateName = typeof template3 === "string" ? template3 : template3.name;
-                          return templateName === itemTemplateName;
-                        });
-                        if (typeof template2 === "string") {
-                          throw new Error(`Global templates not yet supported for rich text`);
-                        }
-                        if (!template2) {
-                          throw new Error(`Unable to find template for field ${field2.name}`);
-                        }
-                        const v = {};
-                        template2.fields.forEach((field3) => {
-                          const fieldValue = itemValues[field3.name];
-                          if (fieldValue) {
-                            switch (field3.type) {
-                              case "boolean":
-                              case "number":
-                                v[field3.name] = `${fieldValue}`;
-                                break;
-                              case "image":
-                              case "datetime":
-                              case "string":
-                                v[field3.name] = `"${fieldValue}"`;
-                                break;
-                            }
-                            v["_template"] = `"${template2.name}"`;
-                          }
-                        });
-                        values.push(v);
-                      });
-                    }
-                  });
-                  if (values.length > 0) {
-                    const ast = {
-                      type: "mdxJsxAttributeValueExpression",
-                      name: key,
-                      value: {
-                        value: `[${values.map((item) => {
-                          return `{${Object.entries(item).map(([key2, value2]) => {
-                            return `${key2}: ${value2}`;
-                          }).join(", ")}}`;
-                        }).join(", ")}]`
-                      }
-                    };
-                    atts.push(__spreadValues({ name: key }, ast));
-                  }
-                } else {
-                  if (field2.fields) {
-                    const v = {};
-                    if (typeof field2.fields === "string") {
-                      throw new Error(`Global templates not yet supported for rich text`);
-                    }
-                    field2.fields.forEach((field3) => {
-                      const fieldValue = value[field3.name];
-                      switch (field3.type) {
-                        case "boolean":
-                        case "number":
-                          v[field3.name] = `${fieldValue}`;
-                          break;
-                        case "image":
-                        case "datetime":
-                        case "string":
-                          v[field3.name] = `"${fieldValue}"`;
-                          break;
-                      }
-                    });
-                    const ast = {
-                      type: "mdxJsxAttributeValueExpression",
-                      name: key,
-                      value: {
-                        value: `{${Object.entries(v).map(([key2, value2]) => {
-                          return `${key2}: ${value2}`;
-                        }).join(", ")}}`
-                      }
-                    };
-                    atts.push(__spreadValues({ name: key }, ast));
-                  } else {
-                    throw new Error("Templates not yet");
-                  }
-                }
-                break;
-              case "rich-text":
-                const tree = value.children.map((item) => stringify(item, field2)).filter((item) => {
-                  if (item.type === "text" && !item.text) {
-                    return false;
-                  }
-                  return true;
-                });
-                if (field2.name === "children") {
-                  children = tree;
-                } else {
-                  const out = (0, import_mdast_util_to_markdown.toMarkdown)({
-                    type: "root",
-                    children: tree
-                  }, { extensions: [import_mdast_util_mdx.mdxToMarkdown] });
-                  if (out) {
-                    atts.push({
-                      type: "mdxJsxAttribute",
-                      name: key,
-                      value: {
-                        value: `
-<>
-${out}
-</>
-`
-                      }
-                    });
-                  }
-                }
-                break;
-              default:
-                atts.push({
-                  type: "mdxJsxAttribute",
-                  name: key,
-                  value: "not yet"
-                });
-                break;
-            }
-          } else {
-            throw new Error(`Templates not yet supported`);
-          }
-        });
-        return __spreadProps(__spreadValues({}, node), {
-          children,
-          attributes: atts
-        });
-      } catch (e) {
-        console.log(e);
-      }
-    case "text":
-      return {
-        type: "text",
-        value: node.text || ""
-      };
-    default:
-      console.log(`Unrecognized field type: ${node.type}`);
-      break;
-  }
-  return { type: "text", value: "" };
-};
-
-// ../graphql/src/primitives/resolver/index.ts
 var createResolver = (args) => {
   return new Resolver(args);
 };
@@ -2240,7 +1596,6 @@ var Resolver = class {
         };
       } catch (e) {
         if (e instanceof TinaError) {
-          console.log(e);
           throw new TinaError(e.message, __spreadValues({
             requestedDocument: fullPath
           }, e.extensions));
@@ -2397,9 +1752,6 @@ var Resolver = class {
               }
               break;
             }
-          case "rich-text":
-            accum[fieldName] = stringifyMDX(fieldValue, field);
-            break;
           case "reference":
             accum[fieldName] = fieldValue;
             break;
@@ -2425,10 +1777,6 @@ var Resolver = class {
         case "image":
           accumulator[field.name] = value;
           break;
-        case "rich-text":
-          const tree = parseMDX(value, field);
-          accumulator[field.name] = tree;
-          break;
         case "object":
           if (field.list) {
             if (!value) {
@@ -2552,13 +1900,13 @@ var Resolver = class {
               }))
             }), extraFields);
           } else if (templateInfo.type === "union") {
-            const templates2 = {};
-            const typeMap2 = {};
+            const templates = {};
+            const typeMap = {};
             yield sequential(templateInfo.templates, (template) => __async(this, null, function* () {
               const extraFields2 = template.ui || {};
               const templateName = lastItem(template.namespace);
-              typeMap2[templateName] = NAMER.dataTypeName(template.namespace);
-              templates2[lastItem(template.namespace)] = __spreadValues({
+              typeMap[templateName] = NAMER.dataTypeName(template.namespace);
+              templates[lastItem(template.namespace)] = __spreadValues({
                 label: template.label || templateName,
                 key: templateName,
                 fields: yield sequential(template.fields, (field2) => __async(this, null, function* () {
@@ -2568,35 +1916,13 @@ var Resolver = class {
               return true;
             }));
             return __spreadValues(__spreadProps(__spreadValues({}, field), {
-              typeMap: typeMap2,
+              typeMap,
               component: field.list ? "blocks" : "not-implemented",
-              templates: templates2
+              templates
             }), extraFields);
           } else {
             throw new Error(`Unknown object for resolveField function`);
           }
-        case "rich-text":
-          const templates = {};
-          const typeMap = {};
-          yield sequential(field.templates, (template) => __async(this, null, function* () {
-            const extraFields2 = template.ui || {};
-            const templateName = lastItem(template.namespace);
-            typeMap[templateName] = NAMER.dataTypeName(template.namespace);
-            templates[lastItem(template.namespace)] = __spreadValues({
-              label: template.label || templateName,
-              key: templateName,
-              inline: template.inline,
-              name: templateName,
-              fields: yield sequential(template.fields, (field2) => __async(this, null, function* () {
-                return yield this.resolveField(field2);
-              }))
-            }, extraFields2);
-            return true;
-          }));
-          return __spreadValues(__spreadProps(__spreadValues({}, field), {
-            templates: Object.values(templates),
-            component: "rich-text"
-          }), extraFields);
         case "reference":
           const documents = import_lodash5.default.flatten(yield sequential(field.collections, (collectionName) => __async(this, null, function* () {
             return this.database.getDocumentsForCollection(collectionName);
@@ -3125,7 +2451,7 @@ var Database = class {
         const templateName = hasOwnProperty(contentObject, "_template") && typeof contentObject._template === "string" ? contentObject._template : void 0;
         const { collection, template } = yield tinaSchema.getCollectionAndTemplateByFullPath(filepath, templateName);
         const field = template.fields.find((field2) => {
-          if (field2.type === "string" || field2.type === "rich-text") {
+          if (field2.type === "string") {
             if (field2.isBody) {
               return true;
             }
@@ -3133,7 +2459,7 @@ var Database = class {
           return false;
         });
         let data = contentObject;
-        if ((extension === ".md" || extension === ".mdx") && field) {
+        if (extension === ".md" && field) {
           if (hasOwnProperty(contentObject, "$_body")) {
             const _b = contentObject, { $_body } = _b, rest = __objRest(_b, ["$_body"]);
             data = rest;
@@ -3170,7 +2496,7 @@ var Database = class {
           throw new Error(`Unable to determine template`);
         }
         const field = template.fields.find((field2) => {
-          if (field2.type === "string" || field2.type === "rich-text") {
+          if (field2.type === "string") {
             if (field2.isBody) {
               return true;
             }
@@ -3178,7 +2504,7 @@ var Database = class {
           return false;
         });
         let payload = {};
-        if (["md", "mdx"].includes(collection.format) && field) {
+        if (collection.format === "md" && field) {
           Object.entries(data).forEach(([key, value]) => {
             if (key !== field.name) {
               payload[key] = value;
@@ -3259,15 +2585,13 @@ var Database = class {
     this.stringifyFile = (content, format, keepTemplateKey) => {
       switch (format) {
         case ".markdown":
-        case ".mdx":
         case ".md":
           const _a = content, { _id, _template, _collection, $_body } = _a, rest = __objRest(_a, ["_id", "_template", "_collection", "$_body"]);
           const extra = {};
           if (keepTemplateKey) {
             extra["_template"] = _template;
           }
-          return import_gray_matter.default.stringify(`
-${$_body}` || "\n", __spreadValues(__spreadValues({}, rest), extra));
+          return import_gray_matter.default.stringify($_body || "", __spreadValues(__spreadValues({}, rest), extra));
         case ".json":
           return JSON.stringify(content, null, 2);
         default:
@@ -3277,7 +2601,6 @@ ${$_body}` || "\n", __spreadValues(__spreadValues({}, rest), extra));
     this.parseFile = (content, format, yupSchema) => {
       switch (format) {
         case ".markdown":
-        case ".mdx":
         case ".md":
           const contentJSON = (0, import_gray_matter.default)(content || "");
           const markdownData = __spreadProps(__spreadValues({}, contentJSON.data), {