@tinacms/graphql 0.56.0 → 0.56.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # tina-graphql
 
+## 0.56.1
+
+### Patch Changes
+
+- 4b7795612: Adds support for collection.templates to TinaAdmin
+
 ## 0.56.0
 
 ### Minor Changes

package/dist/index.js

@@ -11264,11 +11264,6 @@ var Builder = class {
       return astBuilder.FieldDefinition({
         name: "createDocument",
         args: [
-          astBuilder.InputValueDefinition({
-            name: "collection",
-            required: true,
-            type: astBuilder.TYPES.String
-          }),
           astBuilder.InputValueDefinition({
             name: "relativePath",
             required: true,
@@ -11291,11 +11286,6 @@ var Builder = class {
       return astBuilder.FieldDefinition({
         name: "updateDocument",
         args: [
-          astBuilder.InputValueDefinition({
-            name: "collection",
-            required: true,
-            type: astBuilder.TYPES.String
-          }),
           astBuilder.InputValueDefinition({
             name: "relativePath",
             required: true,
@@ -21446,6 +21436,7 @@ var Resolver = class {
               const templates = {};
               await sequential(collectable.templates, async (template) => {
                 templates[lastItem(template.namespace)] = {
+                  template,
                   fields: await sequential(template.fields, async (field) => {
                     return this.resolveField(field);
                   })
@@ -21464,64 +21455,111 @@ var Resolver = class {
         throw e;
       }
     };
-    this.resolveDocument = async ({
-      value,
-      args,
-      collection: collectionName,
-      isMutation,
-      isCreation
-    }) => {
-      const collectionNames = this.tinaSchema.getCollections().map((item) => item.name);
-      assertShape(collectionName, (yup2) => {
-        return yup2.mixed().oneOf(collectionNames);
-      }, `"collection" must be one of: [${collectionNames.join(", ")}] but got ${collectionName}`);
-      assertShape(args, (yup2) => yup2.object({ relativePath: yup2.string().required() }));
-      const collection = await this.tinaSchema.getCollection(collectionName);
-      const realPath = import_path3.default.join(collection == null ? void 0 : collection.path, args.relativePath);
-      if (isMutation) {
-        if (isCreation) {
-          if (await this.database.documentExists(realPath)) {
-            throw new Error(`Unable to add document, ${realPath} already exists`);
-          }
-          const templateInfo2 = this.tinaSchema.getTemplatesForCollectable(collection);
-          switch (templateInfo2.type) {
-            case "object":
-              await this.database.put(realPath, {});
-              break;
-            case "union":
-              const templateString = args.template;
-              const template = templateInfo2.templates.find((template2) => lastItem(template2.namespace) === templateString);
-              if (!args.template) {
-                throw new Error(`Must specify a template when creating content for a collection with multiple templates. Possible templates are: ${templateInfo2.templates.map((t) => lastItem(t.namespace)).join(" ")}`);
-              }
-              if (!template) {
-                throw new Error(`Expected to find template named ${templateString} in collection "${collectionName}" but none was found. Possible templates are: ${templateInfo2.templates.map((t) => lastItem(t.namespace)).join(" ")}`);
+    this.buildObjectMutations = (fieldValue, field) => {
+      if (field.fields) {
+        const objectTemplate = typeof field.fields === "string" ? this.tinaSchema.getGlobalTemplate(field.fields) : field;
+        if (Array.isArray(fieldValue)) {
+          return fieldValue.map((item) => this.buildFieldMutations(item, objectTemplate));
+        } else {
+          return this.buildFieldMutations(fieldValue, objectTemplate);
+        }
+      }
+      if (field.templates) {
+        if (Array.isArray(fieldValue)) {
+          return fieldValue.map((item) => {
+            if (typeof item === "string") {
+              throw new Error(`Expected object for template value for field ${field.name}`);
+            }
+            const templates = field.templates.map((templateOrTemplateName) => {
+              if (typeof templateOrTemplateName === "string") {
+                return this.tinaSchema.getGlobalTemplate(templateOrTemplateName);
               }
-              await this.database.put(realPath, {
-                _template: lastItem(template.namespace)
-              });
-              return this.getDocument(realPath);
-          }
+              return templateOrTemplateName;
+            });
+            const [templateName] = Object.entries(item)[0];
+            const template = templates.find((template2) => template2.name === templateName);
+            if (!template) {
+              throw new Error(`Expected to find template ${templateName}`);
+            }
+            return __spreadProps(__spreadValues({}, this.buildFieldMutations(item[template.name], template)), {
+              _template: template.name
+            });
+          });
         } else {
-          if (!await this.database.documentExists(realPath)) {
-            throw new Error(`Unable to update document, ${realPath} does not exist`);
+          if (typeof fieldValue === "string") {
+            throw new Error(`Expected object for template value for field ${field.name}`);
+          }
+          const templates = field.templates.map((templateOrTemplateName) => {
+            if (typeof templateOrTemplateName === "string") {
+              return this.tinaSchema.getGlobalTemplate(templateOrTemplateName);
+            }
+            return templateOrTemplateName;
+          });
+          const [templateName] = Object.entries(fieldValue)[0];
+          const template = templates.find((template2) => template2.name === templateName);
+          if (!template) {
+            throw new Error(`Expected to find template ${templateName}`);
           }
+          return __spreadProps(__spreadValues({}, this.buildFieldMutations(fieldValue[template.name], template)), {
+            _template: template.name
+          });
         }
+      }
+    };
+    this.createResolveDocument = async ({
+      collection,
+      realPath,
+      args,
+      isAddPendingDocument
+    }) => {
+      if (isAddPendingDocument === true) {
         const templateInfo = this.tinaSchema.getTemplatesForCollectable(collection);
-        const params = this.buildParams(args);
         switch (templateInfo.type) {
           case "object":
-            if (params) {
-              const values = this.buildFieldMutations(params, templateInfo.template);
+            await this.database.put(realPath, {});
+            break;
+          case "union":
+            const templateString = args.template;
+            const template = templateInfo.templates.find((template2) => lastItem(template2.namespace) === templateString);
+            if (!args.template) {
+              throw new Error(`Must specify a template when creating content for a collection with multiple templates. Possible templates are: ${templateInfo.templates.map((t) => lastItem(t.namespace)).join(" ")}`);
+            }
+            if (!template) {
+              throw new Error(`Expected to find template named ${templateString} in collection "${collection.name}" but none was found. Possible templates are: ${templateInfo.templates.map((t) => lastItem(t.namespace)).join(" ")}`);
+            }
+            await this.database.put(realPath, {
+              _template: lastItem(template.namespace)
+            });
+        }
+        return this.getDocument(realPath);
+      }
+      const params = this.buildObjectMutations(args.params[collection.name], collection);
+      await this.database.put(realPath, params);
+      return this.getDocument(realPath);
+    };
+    this.updateResolveDocument = async ({
+      collection,
+      realPath,
+      args,
+      isAddPendingDocument,
+      isCollectionSpecific
+    }) => {
+      if (isAddPendingDocument === true) {
+        const templateInfo = this.tinaSchema.getTemplatesForCollectable(collection);
+        const params2 = this.buildParams(args);
+        switch (templateInfo.type) {
+          case "object":
+            if (params2) {
+              const values = this.buildFieldMutations(params2, templateInfo.template);
               await this.database.put(realPath, values);
             }
             break;
           case "union":
             await sequential(templateInfo.templates, async (template) => {
-              const templateParams = params[lastItem(template.namespace)];
+              const templateParams = params2[lastItem(template.namespace)];
               if (templateParams) {
                 if (typeof templateParams === "string") {
-                  throw new Error(`Expected to find an objet for template params, but got string`);
+                  throw new Error(`Expected to find an object for template params, but got string`);
                 }
                 const values = __spreadProps(__spreadValues({}, this.buildFieldMutations(templateParams, template)), {
                   _template: lastItem(template.namespace)
@@ -21530,9 +21568,58 @@ var Resolver = class {
               }
             });
         }
+        return this.getDocument(realPath);
       }
+      const params = this.buildObjectMutations(isCollectionSpecific ? args.params : args.params[collection.name], collection);
+      await this.database.put(realPath, params);
       return this.getDocument(realPath);
     };
+    this.resolveDocument = async ({
+      args,
+      collection: collectionName,
+      isMutation,
+      isCreation,
+      isAddPendingDocument,
+      isCollectionSpecific
+    }) => {
+      let collectionLookup = collectionName || void 0;
+      if (!collectionLookup && isCollectionSpecific === false) {
+        collectionLookup = Object.keys(args.params)[0];
+      }
+      const collectionNames = this.tinaSchema.getCollections().map((item) => item.name);
+      assertShape(collectionLookup, (yup2) => {
+        return yup2.mixed().oneOf(collectionNames);
+      }, `"collection" must be one of: [${collectionNames.join(", ")}] but got ${collectionLookup}`);
+      assertShape(args, (yup2) => yup2.object({ relativePath: yup2.string().required() }));
+      const collection = await this.tinaSchema.getCollection(collectionLookup);
+      const realPath = import_path3.default.join(collection == null ? void 0 : collection.path, args.relativePath);
+      const alreadyExists = await this.database.documentExists(realPath);
+      if (isMutation) {
+        if (isCreation) {
+          if (alreadyExists === true) {
+            throw new Error(`Unable to add document, ${realPath} already exists`);
+          }
+          return this.createResolveDocument({
+            collection,
+            realPath,
+            args,
+            isAddPendingDocument
+          });
+        }
+        if (alreadyExists === false) {
+          throw new Error(`Unable to update document, ${realPath} does not exist`);
+        }
+        return this.updateResolveDocument({
+          collection,
+          realPath,
+          args,
+          isAddPendingDocument,
+          isCollectionSpecific
+        });
+      } else {
+        return this.getDocument(realPath);
+      }
+    };
     this.resolveCollectionConnections = async ({ ids }) => {
       return {
         totalCount: ids.length,
@@ -21582,40 +21669,7 @@ var Resolver = class {
             accum[fieldName] = fieldValue;
             break;
           case "object":
-            if (field.fields) {
-              const objectTemplate = typeof field.fields === "string" ? this.tinaSchema.getGlobalTemplate(field.fields) : field;
-              if (Array.isArray(fieldValue)) {
-                accum[fieldName] = fieldValue.map((item) => this.buildFieldMutations(item, objectTemplate));
-              } else {
-                accum[fieldName] = this.buildFieldMutations(fieldValue, objectTemplate);
-              }
-              break;
-            }
-            if (field.templates) {
-              if (Array.isArray(fieldValue)) {
-                accum[fieldName] = fieldValue.map((item) => {
-                  if (typeof item === "string") {
-                    throw new Error(`Expected object for template value for field ${field.name}`);
-                  }
-                  const templates = field.templates.map((templateOrTemplateName) => {
-                    if (typeof templateOrTemplateName === "string") {
-                      return this.tinaSchema.getGlobalTemplate(templateOrTemplateName);
-                    }
-                    return templateOrTemplateName;
-                  });
-                  const [templateName] = Object.entries(item)[0];
-                  const template2 = templates.find((template3) => template3.name === templateName);
-                  if (!template2) {
-                    throw new Error(`Expected to find template ${templateName}`);
-                  }
-                  return __spreadProps(__spreadValues({}, this.buildFieldMutations(item[template2.name], template2)), {
-                    _template: template2.name
-                  });
-                });
-              } else {
-                throw new Error("Not implement for polymorphic objects which are not lists");
-              }
-            }
+            accum[fieldName] = this.buildObjectMutations(fieldValue, field);
             break;
           case "rich-text":
             field;
@@ -21956,20 +22010,21 @@ var resolve = async ({
             }
             if (args && args.collection && info.fieldName === "addPendingDocument") {
               return resolver2.resolveDocument({
-                value,
                 args: __spreadProps(__spreadValues({}, args), { params: {} }),
                 collection: args.collection,
                 isMutation,
-                isCreation: true
+                isCreation: true,
+                isAddPendingDocument: true
               });
             }
             if (["getDocument", "createDocument", "updateDocument"].includes(info.fieldName)) {
               const result2 = await resolver2.resolveDocument({
-                value,
                 args,
                 collection: args.collection,
                 isMutation,
-                isCreation
+                isCreation,
+                isAddPendingDocument: false,
+                isCollectionSpecific: false
               });
               if (!isMutation) {
                 const mutationPath = buildMutationPath(info, {
@@ -21992,11 +22047,12 @@ var resolve = async ({
               return value;
             }
             const result = value || await resolver2.resolveDocument({
-              value,
               args,
               collection: lookup.collection,
               isMutation,
-              isCreation
+              isCreation,
+              isAddPendingDocument: false,
+              isCollectionSpecific: true
             });
             if (!isMutation) {
               const mutationPath = buildMutationPath(info, {

package/dist/primitives/resolver/index.d.ts

@@ -12,6 +12,7 @@ limitations under the License.
 */
 import { TinaSchema } from '../schema';
 import { Database, CollectionDocumentListLookup } from '../database';
+import type { Collectable, TinaCloudCollection } from '../types';
 interface ResolverConfig {
     database: Database;
     tinaSchema: TinaSchema;
@@ -65,7 +66,7 @@ export declare class Resolver {
             path: string;
             relativePath: string;
             breadcrumbs: string[];
-            collection: import("../types").TinaCloudCollection<true>;
+            collection: TinaCloudCollection<true>;
             template: string | number;
         };
         data: {
@@ -87,12 +88,91 @@ export declare class Resolver {
         };
     }>;
     getDocumentFields: () => Promise<{}>;
-    resolveDocument: ({ value, args, collection: collectionName, isMutation, isCreation, }: {
-        value: unknown;
+    buildObjectMutations: (fieldValue: any, field: Collectable) => {
+        [key: string]: unknown;
+    } | {
+        [key: string]: unknown;
+    }[];
+    createResolveDocument: ({ collection, realPath, args, isAddPendingDocument, }: {
+        collection: TinaCloudCollection<true>;
+        realPath: string;
+        args: unknown;
+        isAddPendingDocument: boolean;
+    }) => Promise<{
+        __typename: string;
+        id: string;
+        sys: {
+            basename: string;
+            filename: string;
+            extension: string;
+            path: string;
+            relativePath: string;
+            breadcrumbs: string[];
+            collection: TinaCloudCollection<true>;
+            template: string | number;
+        };
+        data: {
+            _collection: string;
+            _template: string;
+        };
+        values: {
+            _collection: string;
+            _template: string;
+        };
+        dataJSON: {
+            _collection: string;
+            _template: string;
+        };
+        form: {
+            label: string;
+            name: string;
+            fields: unknown[];
+        };
+    }>;
+    updateResolveDocument: ({ collection, realPath, args, isAddPendingDocument, isCollectionSpecific, }: {
+        collection: TinaCloudCollection<true>;
+        realPath: string;
+        args: unknown;
+        isAddPendingDocument: boolean;
+        isCollectionSpecific: boolean;
+    }) => Promise<{
+        __typename: string;
+        id: string;
+        sys: {
+            basename: string;
+            filename: string;
+            extension: string;
+            path: string;
+            relativePath: string;
+            breadcrumbs: string[];
+            collection: TinaCloudCollection<true>;
+            template: string | number;
+        };
+        data: {
+            _collection: string;
+            _template: string;
+        };
+        values: {
+            _collection: string;
+            _template: string;
+        };
+        dataJSON: {
+            _collection: string;
+            _template: string;
+        };
+        form: {
+            label: string;
+            name: string;
+            fields: unknown[];
+        };
+    }>;
+    resolveDocument: ({ args, collection: collectionName, isMutation, isCreation, isAddPendingDocument, isCollectionSpecific, }: {
         args: unknown;
-        collection: string;
+        collection?: string;
         isMutation: boolean;
         isCreation?: boolean;
+        isAddPendingDocument?: boolean;
+        isCollectionSpecific?: boolean;
     }) => Promise<{
         __typename: string;
         id: string;
@@ -103,7 +183,7 @@ export declare class Resolver {
             path: string;
             relativePath: string;
             breadcrumbs: string[];
-            collection: import("../types").TinaCloudCollection<true>;
+            collection: TinaCloudCollection<true>;
             template: string | number;
         };
         data: {
@@ -139,7 +219,7 @@ export declare class Resolver {
                     path: string;
                     relativePath: string;
                     breadcrumbs: string[];
-                    collection: import("../types").TinaCloudCollection<true>;
+                    collection: TinaCloudCollection<true>;
                     template: string | number;
                 };
                 data: {
@@ -178,7 +258,7 @@ export declare class Resolver {
                     path: string;
                     relativePath: string;
                     breadcrumbs: string[];
-                    collection: import("../types").TinaCloudCollection<true>;
+                    collection: TinaCloudCollection<true>;
                     template: string | number;
                 };
                 data: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/graphql",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [