@tinacms/graphql 2.0.6 → 2.1.1

package/dist/database/util.d.ts

@@ -8,10 +8,12 @@ export declare const stringifyFile: (content: object, format: ContentFormat | st
 keepTemplateKey: boolean, markdownParseConfig?: {
     frontmatterFormat?: ContentFrontmatterFormat;
     frontmatterDelimiters?: [string, string] | string;
+    yamlMaxLineWidth?: number;
 }) => string;
 export declare const parseFile: <T extends object>(content: string, format: ContentFormat | string, // FIXME
 yupSchema: (args: typeof yup) => yup.ObjectSchema<any>, markdownParseConfig?: {
     frontmatterFormat?: ContentFrontmatterFormat;
+    lineWidth?: number;
     frontmatterDelimiters?: [string, string] | string;
 }) => T;
 export declare const atob: (b64Encoded: string) => string;

package/dist/index.js

@@ -3026,7 +3026,7 @@ var validateField = async (field) => {
 var package_default = {
   name: "@tinacms/graphql",
   type: "module",
-  version: "2.0.6",
+  version: "2.1.1",
   main: "dist/index.js",
   module: "./dist/index.js",
   files: [
@@ -3083,7 +3083,7 @@ var package_default = {
   },
   repository: {
     url: "https://github.com/tinacms/tinacms.git",
-    directory: "packages/tina-graphql"
+    directory: "packages/@tinacms/graphql"
   },
   devDependencies: {
     "@tinacms/schema-tools": "workspace:*",
@@ -3580,13 +3580,21 @@ var stringifyFile = (content, format, keepTemplateKey, markdownParseConfig) => {
     case ".markdown":
     case ".mdx":
     case ".md":
+      const yamlMaxLineWidth = markdownParseConfig?.yamlMaxLineWidth ?? -1;
+      const enginesWithYaml = {
+        ...matterEngines,
+        yaml: {
+          parse: (val) => yaml.safeLoad(val),
+          stringify: (val) => yaml.safeDump(val, { lineWidth: yamlMaxLineWidth })
+        }
+      };
       const ok = matter.stringify(
         typeof $_body === "undefined" ? "" : `
 ${$_body}`,
         strippedContent,
         {
           language: markdownParseConfig?.frontmatterFormat ?? "yaml",
-          engines: matterEngines,
+          engines: enginesWithYaml,
           delimiters: markdownParseConfig?.frontmatterDelimiters ?? "---"
         }
       );
@@ -3595,7 +3603,9 @@ ${$_body}`,
       return JSON.stringify(strippedContent, null, 2);
     case ".yaml":
     case ".yml":
-      return yaml.safeDump(strippedContent);
+      return yaml.safeDump(strippedContent, {
+        lineWidth: markdownParseConfig?.yamlMaxLineWidth ?? -1
+      });
     case ".toml":
       return toml.stringify(strippedContent);
     default:
@@ -6055,6 +6065,7 @@ var resolve = async ({
       tinaSchema,
       isAudit: isAudit || false
     });
+    const resolverPromises = [];
     const res = await graphql({
       schema: graphQLSchema,
       source: query,
@@ -6072,302 +6083,307 @@ var resolve = async ({
         throw new Error(`Unable to find lookup key for ${namedType}`);
       },
       fieldResolver: async (source = {}, args = {}, _context, info) => {
-        try {
-          const returnType = getNamedType(info.returnType).toString();
-          if (returnType === "Collection") {
-            const possibleCollectionValue = source[info.fieldName];
-            if (possibleCollectionValue) {
-              return possibleCollectionValue;
+        const fieldPromise = (async () => {
+          try {
+            const returnType = getNamedType(info.returnType).toString();
+            if (returnType === "Collection") {
+              const possibleCollectionValue = source[info.fieldName];
+              if (possibleCollectionValue) {
+                return possibleCollectionValue;
+              }
+              if (info.fieldName === "collections") {
+                return handleCollectionsField(info, tinaSchema, resolver, args);
+              }
+              return handleCollectionField(info, args, resolver);
             }
-            if (info.fieldName === "collections") {
-              return handleCollectionsField(info, tinaSchema, resolver, args);
+            if (info.fieldName === "getOptimizedQuery") {
+              return args.queryString || "";
             }
-            return handleCollectionField(info, args, resolver);
-          }
-          if (info.fieldName === "getOptimizedQuery") {
-            return args.queryString || "";
-          }
-          if (info.fieldName === "authenticate") {
-            const authArgs = args;
-            return handleAuthenticate({
-              tinaSchema,
-              resolver,
-              sub: authArgs.sub,
-              password: authArgs.password,
-              info,
-              ctxUser
-            });
-          }
-          if (info.fieldName === "authorize") {
-            const authArgs = args;
-            return handleAuthorize({
-              tinaSchema,
-              resolver,
-              sub: authArgs.sub,
-              info,
-              ctxUser
-            });
-          }
-          if (info.fieldName === "updatePassword") {
-            const authArgs = args;
-            return handleUpdatePassword({
-              tinaSchema,
-              resolver,
-              password: authArgs.password,
-              info,
-              ctxUser
-            });
-          }
-          const lookup = await database.getLookup(returnType);
-          if (!lookup) {
-            return source[info.fieldName];
-          }
-          const isCreation = lookup[info.fieldName] === "create";
-          const isMutation = info.parentType.toString() === "Mutation";
-          switch (lookup.resolveType) {
-            /*
-             * `node(id: $id)`
-             */
-            case "nodeDocument":
-              assertShape(
-                args,
-                (yup3) => yup3.object({ id: yup3.string().required() })
-              );
-              return resolver.getDocument(args.id);
-            case "multiCollectionDocument":
-              const possibleValue = source[info.fieldName];
-              if (typeof possibleValue === "string" && possibleValue !== "") {
-                return resolver.getDocument(possibleValue);
-              }
-              if ([
-                NAMER.documentQueryName(),
-                "addPendingDocument",
-                "createDocument",
-                "updateDocument",
-                "deleteDocument",
-                "createFolder"
-              ].includes(info.fieldName)) {
+            if (info.fieldName === "authenticate") {
+              const authArgs = args;
+              return handleAuthenticate({
+                tinaSchema,
+                resolver,
+                sub: authArgs.sub,
+                password: authArgs.password,
+                info,
+                ctxUser
+              });
+            }
+            if (info.fieldName === "authorize") {
+              const authArgs = args;
+              return handleAuthorize({
+                tinaSchema,
+                resolver,
+                sub: authArgs.sub,
+                info,
+                ctxUser
+              });
+            }
+            if (info.fieldName === "updatePassword") {
+              const authArgs = args;
+              return handleUpdatePassword({
+                tinaSchema,
+                resolver,
+                password: authArgs.password,
+                info,
+                ctxUser
+              });
+            }
+            const lookup = await database.getLookup(returnType);
+            if (!lookup) {
+              return source[info.fieldName];
+            }
+            const isCreation = lookup[info.fieldName] === "create";
+            const isMutation = info.parentType.toString() === "Mutation";
+            switch (lookup.resolveType) {
+              /*
+               * `node(id: $id)`
+               */
+              case "nodeDocument":
                 assertShape(
                   args,
-                  (yup3) => yup3.object({
-                    collection: yup3.string().required(),
-                    relativePath: yup3.string().required()
-                  })
+                  (yup3) => yup3.object({ id: yup3.string().required() })
                 );
-                if (isMutation) {
-                  switch (info.fieldName) {
-                    case "addPendingDocument":
-                      return resolver.resolveAddPendingDocument({
-                        collectionName: args.collection,
-                        relativePath: args.relativePath,
-                        templateName: args.template
-                      });
-                    case "createFolder":
-                      return resolver.resolveCreateFolder({
-                        collectionName: args.collection,
-                        relativePath: args.relativePath
-                      });
-                    case "createDocument": {
-                      assertShape(
-                        args,
-                        (yup3) => yup3.object({
-                          params: yup3.object().shape({
-                            [args.collection]: yup3.object().required()
-                          }).required()
-                        })
-                      );
-                      return resolver.resolveCreateDocument({
-                        collectionName: args.collection,
-                        relativePath: args.relativePath,
-                        body: args.params[args.collection]
-                      });
-                    }
-                    case "updateDocument": {
-                      assertShape(
-                        args,
-                        (yup3) => yup3.object({
-                          params: yup3.object().shape({
-                            relativePath: yup3.string().optional()
-                          }).required()
-                        })
-                      );
-                      const newRelativePath = args.params.relativePath;
-                      const newBody = args.params[args.collection];
-                      return resolver.resolveUpdateDocument({
-                        collectionName: args.collection,
-                        relativePath: args.relativePath,
-                        newRelativePath,
-                        newBody
-                      });
+                return resolver.getDocument(args.id);
+              case "multiCollectionDocument":
+                const possibleValue = source[info.fieldName];
+                if (typeof possibleValue === "string" && possibleValue !== "") {
+                  return resolver.getDocument(possibleValue);
+                }
+                if ([
+                  NAMER.documentQueryName(),
+                  "addPendingDocument",
+                  "createDocument",
+                  "updateDocument",
+                  "deleteDocument",
+                  "createFolder"
+                ].includes(info.fieldName)) {
+                  assertShape(
+                    args,
+                    (yup3) => yup3.object({
+                      collection: yup3.string().required(),
+                      relativePath: yup3.string().required()
+                    })
+                  );
+                  if (isMutation) {
+                    switch (info.fieldName) {
+                      case "addPendingDocument":
+                        return resolver.resolveAddPendingDocument({
+                          collectionName: args.collection,
+                          relativePath: args.relativePath,
+                          templateName: args.template
+                        });
+                      case "createFolder":
+                        return resolver.resolveCreateFolder({
+                          collectionName: args.collection,
+                          relativePath: args.relativePath
+                        });
+                      case "createDocument": {
+                        assertShape(
+                          args,
+                          (yup3) => yup3.object({
+                            params: yup3.object().shape({
+                              [args.collection]: yup3.object().required()
+                            }).required()
+                          })
+                        );
+                        return resolver.resolveCreateDocument({
+                          collectionName: args.collection,
+                          relativePath: args.relativePath,
+                          body: args.params[args.collection]
+                        });
+                      }
+                      case "updateDocument": {
+                        assertShape(
+                          args,
+                          (yup3) => yup3.object({
+                            params: yup3.object().shape({
+                              relativePath: yup3.string().optional()
+                            }).required()
+                          })
+                        );
+                        const newRelativePath = args.params.relativePath;
+                        const newBody = args.params[args.collection];
+                        return resolver.resolveUpdateDocument({
+                          collectionName: args.collection,
+                          relativePath: args.relativePath,
+                          newRelativePath,
+                          newBody
+                        });
+                      }
+                      case "deleteDocument":
+                        return resolver.resolveDeleteDocument({
+                          collectionName: args.collection,
+                          relativePath: args.relativePath
+                        });
                     }
-                    case "deleteDocument":
-                      return resolver.resolveDeleteDocument({
-                        collectionName: args.collection,
-                        relativePath: args.relativePath
-                      });
+                  } else if (info.fieldName === NAMER.documentQueryName()) {
+                    return resolver.resolveRetrievedDocument({
+                      collectionName: args.collection,
+                      relativePath: args.relativePath
+                    });
                   }
-                } else if (info.fieldName === NAMER.documentQueryName()) {
-                  return resolver.resolveRetrievedDocument({
-                    collectionName: args.collection,
-                    relativePath: args.relativePath
+                }
+                return possibleValue;
+              /*
+               * eg `getMovieDocument.data.actors`
+               */
+              case "multiCollectionDocumentList":
+                const listValue = source[info.fieldName];
+                if (Array.isArray(listValue)) {
+                  return {
+                    totalCount: listValue.length,
+                    edges: listValue.map((document) => {
+                      return { node: document };
+                    })
+                  };
+                }
+                if (info.fieldName === "documents" && listValue?.collection && listValue?.hasDocuments) {
+                  const documentsArgs = args;
+                  const collectionName = listValue.collection?.name;
+                  const filter = (collectionName && documentsArgs.filter?.[collectionName]) ?? documentsArgs.filter;
+                  return resolver.resolveCollectionConnection({
+                    args: {
+                      ...documentsArgs,
+                      filter
+                    },
+                    collection: listValue.collection
                   });
                 }
-              }
-              return possibleValue;
-            /*
-             * eg `getMovieDocument.data.actors`
-             */
-            case "multiCollectionDocumentList":
-              const listValue = source[info.fieldName];
-              if (Array.isArray(listValue)) {
-                return {
-                  totalCount: listValue.length,
-                  edges: listValue.map((document) => {
-                    return { node: document };
-                  })
-                };
-              }
-              if (info.fieldName === "documents" && listValue?.collection && listValue?.hasDocuments) {
-                const documentsArgs = args;
-                const collectionName = listValue.collection?.name;
-                const filter = (collectionName && documentsArgs.filter?.[collectionName]) ?? documentsArgs.filter;
-                return resolver.resolveCollectionConnection({
-                  args: {
-                    ...documentsArgs,
-                    filter
-                  },
-                  collection: listValue.collection
-                });
-              }
-              throw new Error(
-                `Expected an array for result of ${info.fieldName} at ${info.path}`
-              );
-            /*
-             * Collections-specific getter
-             * eg. `getPostDocument`/`createPostDocument`/`updatePostDocument`
-             *
-             * if coming from a query result
-             * the field will be `node`
-             */
-            case "collectionDocument": {
-              const possibleDocValue = source[info.fieldName];
-              if (possibleDocValue) {
-                return possibleDocValue;
-              }
-              assertShape(
-                args,
-                (yup3) => yup3.object({
-                  relativePath: yup3.string().required()
-                })
-              );
-              if (isMutation) {
+                throw new Error(
+                  `Expected an array for result of ${info.fieldName} at ${info.path}`
+                );
+              /*
+               * Collections-specific getter
+               * eg. `getPostDocument`/`createPostDocument`/`updatePostDocument`
+               *
+               * if coming from a query result
+               * the field will be `node`
+               */
+              case "collectionDocument": {
+                const possibleDocValue = source[info.fieldName];
+                if (possibleDocValue) {
+                  return possibleDocValue;
+                }
                 assertShape(
                   args,
                   (yup3) => yup3.object({
-                    params: yup3.object().required()
+                    relativePath: yup3.string().required()
                   })
                 );
-                if (isCreation) {
-                  return resolver.resolveCreateDocument({
-                    collectionName: lookup.collection,
-                    relativePath: args.relativePath,
-                    body: args.params
-                  });
-                } else {
-                  return resolver.resolveUpdateDocument({
-                    collectionName: lookup.collection,
-                    relativePath: args.relativePath,
-                    newBody: args.params
-                  });
-                }
-              } else {
-                return resolver.resolveRetrievedDocument({
-                  collectionName: lookup.collection,
-                  relativePath: args.relativePath
-                });
-              }
-            }
-            /*
-             * Collections-specific list getter
-             * eg. `getPageList`
-             */
-            case "collectionDocumentList":
-              const collectionArgs = args;
-              return resolver.resolveCollectionConnection({
-                args: collectionArgs,
-                collection: tinaSchema.getCollection(lookup.collection)
-              });
-            /*
-             * A polymorphic data set, it can be from a document's data
-             * of any nested object which can be one of many shapes
-             *
-             * ```graphql
-             * getPostDocument(relativePath: $relativePath) {
-             *   data {...} <- this part
-             * }
-             * ```
-             * ```graphql
-             * getBlockDocument(relativePath: $relativePath) {
-             *   data {
-             *     blocks {...} <- or this part
-             *   }
-             * }
-             * ```
-             */
-            case "unionData":
-              const unionValue = source[info.fieldName];
-              if (!unionValue) {
-                const unionArgs = args;
-                if (unionArgs.relativePath) {
+                if (isMutation) {
                   assertShape(
                     args,
                     (yup3) => yup3.object({
-                      relativePath: yup3.string().required()
+                      params: yup3.object().required()
                     })
                   );
-                  if (isMutation) {
+                  if (isCreation) {
+                    return resolver.resolveCreateDocument({
+                      collectionName: lookup.collection,
+                      relativePath: args.relativePath,
+                      body: args.params
+                    });
+                  } else {
+                    return resolver.resolveUpdateDocument({
+                      collectionName: lookup.collection,
+                      relativePath: args.relativePath,
+                      newBody: args.params
+                    });
+                  }
+                } else {
+                  return resolver.resolveRetrievedDocument({
+                    collectionName: lookup.collection,
+                    relativePath: args.relativePath
+                  });
+                }
+              }
+              /*
+               * Collections-specific list getter
+               * eg. `getPageList`
+               */
+              case "collectionDocumentList":
+                const collectionArgs = args;
+                return resolver.resolveCollectionConnection({
+                  args: collectionArgs,
+                  collection: tinaSchema.getCollection(lookup.collection)
+                });
+              /*
+               * A polymorphic data set, it can be from a document's data
+               * of any nested object which can be one of many shapes
+               *
+               * ```graphql
+               * getPostDocument(relativePath: $relativePath) {
+               *   data {...} <- this part
+               * }
+               * ```
+               * ```graphql
+               * getBlockDocument(relativePath: $relativePath) {
+               *   data {
+               *     blocks {...} <- or this part
+               *   }
+               * }
+               * ```
+               */
+              case "unionData":
+                const unionValue = source[info.fieldName];
+                if (!unionValue) {
+                  const unionArgs = args;
+                  if (unionArgs.relativePath) {
                     assertShape(
                       args,
                       (yup3) => yup3.object({
-                        params: yup3.object().required()
+                        relativePath: yup3.string().required()
                       })
                     );
-                    if (isCreation) {
-                      return resolver.resolveCreateDocument({
-                        collectionName: lookup.collection,
-                        relativePath: args.relativePath,
-                        body: args.params
-                      });
+                    if (isMutation) {
+                      assertShape(
+                        args,
+                        (yup3) => yup3.object({
+                          params: yup3.object().required()
+                        })
+                      );
+                      if (isCreation) {
+                        return resolver.resolveCreateDocument({
+                          collectionName: lookup.collection,
+                          relativePath: args.relativePath,
+                          body: args.params
+                        });
+                      } else {
+                        return resolver.resolveUpdateDocument({
+                          collectionName: lookup.collection,
+                          relativePath: args.relativePath,
+                          newBody: args.params
+                        });
+                      }
                     } else {
-                      return resolver.resolveUpdateDocument({
+                      return resolver.resolveRetrievedDocument({
                         collectionName: lookup.collection,
-                        relativePath: args.relativePath,
-                        newBody: args.params
+                        relativePath: args.relativePath
                       });
                     }
-                  } else {
-                    return resolver.resolveRetrievedDocument({
-                      collectionName: lookup.collection,
-                      relativePath: args.relativePath
-                    });
                   }
                 }
-              }
-              return unionValue;
-            default:
-              console.error(
-                `Could not recognize resolve type '${lookup.resolveType}'.`
-              );
-              console.error(
-                "The field resolver needs to be updated to handle this new type."
-              );
-              throw new Error("Unexpected resolve type");
+                return unionValue;
+              default:
+                console.error(
+                  `Could not recognize resolve type '${lookup.resolveType}'.`
+                );
+                console.error(
+                  "The field resolver needs to be updated to handle this new type."
+                );
+                throw new Error("Unexpected resolve type");
+            }
+          } catch (e) {
+            handleFetchErrorError(e, verboseValue);
           }
-        } catch (e) {
-          handleFetchErrorError(e, verboseValue);
-        }
+        })();
+        resolverPromises.push(fieldPromise);
+        return fieldPromise;
       }
     });
+    await Promise.allSettled(resolverPromises);
     if (res.errors) {
       if (!silenceErrors) {
         res.errors.map((e) => {
@@ -6968,7 +6984,8 @@ var Database = class {
       //templateInfo.type === 'union',
       {
         frontmatterFormat: collection?.frontmatterFormat,
-        frontmatterDelimiters: collection?.frontmatterDelimiters
+        frontmatterDelimiters: collection?.frontmatterDelimiters,
+        yamlMaxLineWidth: collection?.yamlMaxLineWidth
       }
     );
   };

package/dist/resolver/index.d.ts

@@ -79,6 +79,7 @@ export declare class Resolver {
         defaultItem?: import("@tinacms/schema-tools").DefaultItem<Record<string, any>>;
         frontmatterFormat?: import("@tinacms/schema-tools").ContentFrontmatterFormat;
         frontmatterDelimiters?: [string, string] | string;
+        yamlMaxLineWidth?: number;
         match?: {
             include?: string;
             exclude?: string;
@@ -107,6 +108,7 @@ export declare class Resolver {
         defaultItem?: import("@tinacms/schema-tools").DefaultItem<Record<string, any>>;
         frontmatterFormat?: import("@tinacms/schema-tools").ContentFrontmatterFormat;
         frontmatterDelimiters?: [string, string] | string;
+        yamlMaxLineWidth?: number;
         match?: {
             include?: string;
             exclude?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tinacms/graphql",
   "type": "module",
-  "version": "2.0.6",
+  "version": "2.1.1",
   "main": "dist/index.js",
   "module": "./dist/index.js",
   "files": [
@@ -43,15 +43,15 @@
     "normalize-path": "^3.0.0",
     "readable-stream": "^4.7.0",
     "yup": "^1.6.1",
-    "@tinacms/mdx": "2.0.3",
-    "@tinacms/schema-tools": "2.3.0"
+    "@tinacms/mdx": "2.0.5",
+    "@tinacms/schema-tools": "2.5.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
   "repository": {
     "url": "https://github.com/tinacms/tinacms.git",
-    "directory": "packages/tina-graphql"
+    "directory": "packages/@tinacms/graphql"
   },
   "devDependencies": {
     "@types/cors": "^2.8.17",
@@ -72,7 +72,7 @@
     "vitest": "^0.32.4",
     "zod": "^3.24.2",
     "@tinacms/scripts": "1.4.2",
-    "@tinacms/schema-tools": "2.3.0"
+    "@tinacms/schema-tools": "2.5.0"
   },
   "scripts": {
     "types": "pnpm tsc",