@axinom/mosaic-graphql-codegen-plugins 0.5.0-rc.2 → 0.5.0

package/dist/generate-bulk-edit-ui-config/generate-bulk-edit-ui-config.js

@@ -44,20 +44,27 @@ exports.plugin = plugin;
 function resolveFields(fields, action, postfix = '') {
     const resultingFields = {};
     Object.keys(fields).map((fieldName) => {
+        var _a, _b;
         const field = fields[fieldName];
         let type = field.type.toString();
-        if (Object.keys(field.type).includes('ofType')) {
-            const compositeType = [];
-            Object.keys(field.type.ofType.getFields()).forEach((key) => {
-                const name = field.type.ofType.getFields()[key]
-                    .name;
-                const type = field.type.ofType.getFields()[key]
-                    .type;
-                compositeType.push({
-                    [name]: type,
+        try {
+            // Handle list of composite types
+            const fields = (_b = (_a = field.type.ofType) === null || _a === void 0 ? void 0 : _a.getFields) === null || _b === void 0 ? void 0 : _b.call(_a);
+            if (fields && typeof fields === 'object') {
+                const compositeType = {};
+                Object.keys(fields).forEach((key) => {
+                    const name = fields[key].name;
+                    const type = fields[key].type;
+                    compositeType[name] = type;
                 });
-            });
-            type = compositeType;
+                type = [compositeType];
+            }
+        }
+        catch (error) {
+            // If we encounter an unknown type structure, fall back to toString()
+            // eslint-disable-next-line no-console
+            console.warn(`Warning: Unable to resolve type structure for field "${fieldName}". Using toString() representation.`, error);
+            type = field.type.toString();
         }
         resultingFields[postfix ? `${fieldName}${postfix}` : fieldName] = {
             type: type,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axinom/mosaic-graphql-codegen-plugins",
-  "version": "0.5.0-rc.2",
+  "version": "0.5.0",
   "description": "Library of graphql-codegen plugins for Mosaic workflows",
   "scripts": {
     "dev": "tsc -w",
@@ -8,6 +8,7 @@
     "build": "yarn clean && tsc --project tsconfig.build.json",
     "build:ci": "yarn workspaces focus && yarn build",
     "test": "jest --silent",
+    "test:watch": "jest --watch",
     "lint": "eslint . --ext .ts,.tsx,.js --color --cache"
   },
   "author": "Axinom",
@@ -43,5 +44,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2364d1ad780b65c4974987c3f3ac30e09dfe850e"
+  "gitHead": "b48ca504a563d87a93d0b577c20e52175a90179f"
 }

package/src/generate-bulk-edit-ui-config/generate-bulk-edit-ui-config.spec.ts

@@ -1,5 +1,7 @@
 import {
   GraphQLInputObjectType,
+  GraphQLList,
+  GraphQLNonNull,
   GraphQLObjectType,
   GraphQLSchema,
   GraphQLString,
@@ -69,6 +71,213 @@ describe('generate-bulk-edit-ui-config plugin', () => {
     expect(result).toContain('mutation');
   });
 
+  it('should generate valid config structure with correct keys and mutation name', () => {
+    const result = plugin(schema, [], {}) as string;
+
+    // Check the config contains the header comment
+    expect(result).toContain('/** Bulk Edit Configurations **/');
+
+    // Check bulkEditEntity config structure
+    expect(result).toContain('export const BulkEditEntityFormFieldsConfig');
+    expect(result).toContain("mutation: 'bulkEditEntity'");
+    expect(result).toContain(
+      "keys: { add: 'relatedEntitiesToAdd', remove: 'relatedEntitiesToRemove', set: 'set', filter: 'filter' }",
+    );
+
+    // Validate the config contains proper JSON structure for fields
+    const fieldsMatch = result.match(/fields: (\{[\s\S]*?\})\};/);
+    expect(fieldsMatch).toBeTruthy();
+    expect(fieldsMatch).not.toBeNull();
+
+    // Parse and validate the JSON structure
+    const fieldsJson = JSON.parse(fieldsMatch![1]);
+    expect(fieldsJson).toBeDefined();
+    expect(typeof fieldsJson).toBe('object');
+  });
+
+  it('should generate field configs with correct structure for relatedEntitiesToAdd', () => {
+    const result = plugin(schema, [], {});
+
+    // Should include fields from RelatedEntitiesInput with "Add" postfix
+    expect(result).toContain('"idAdd"');
+    expect(result).toContain('"nameAdd"');
+    expect(result).toContain('"label": "Id (Add)"');
+    expect(result).toContain('"label": "Name (Add)"');
+    expect(result).toContain('"action": "relatedEntitiesToAdd"');
+    expect(result).toContain('"originalFieldName": "id"');
+    expect(result).toContain('"originalFieldName": "name"');
+  });
+
+  it('should generate field configs with correct structure for relatedEntitiesToRemove', () => {
+    const result = plugin(schema, [], {});
+
+    // Should include fields from RelatedEntitiesInput with "Remove" postfix
+    expect(result).toContain('"idRemove"');
+    expect(result).toContain('"nameRemove"');
+    expect(result).toContain('"label": "Id (Remove)"');
+    expect(result).toContain('"label": "Name (Remove)"');
+    expect(result).toContain('"action": "relatedEntitiesToRemove"');
+  });
+
+  it('should generate field configs with correct structure for set', () => {
+    const result = plugin(schema, [], {});
+
+    // Should include fields from SetInput without postfix
+    expect(result).toContain('"status"');
+    expect(result).toContain('"label": "Status"');
+    expect(result).toContain('"action": "set"');
+    expect(result).toContain('"originalFieldName": "status"');
+    expect(result).toContain('"type": "String"');
+  });
+
+  it('should handle list/array fields of primitive types (e.g., [String])', () => {
+    // Create a schema with primitive array fields
+    const PrimitiveArrayInputType = new GraphQLInputObjectType({
+      name: 'PrimitiveArrayInput',
+      fields: {
+        tags: { type: new GraphQLList(GraphQLString) },
+        categories: {
+          type: new GraphQLList(new GraphQLNonNull(GraphQLString)),
+        },
+      },
+    });
+
+    const SetInputType = new GraphQLInputObjectType({
+      name: 'SetInputType',
+      fields: {
+        title: { type: GraphQLString },
+      },
+    });
+
+    const MutationTypeWithPrimitiveArrays = new GraphQLObjectType({
+      name: 'Mutation',
+      fields: {
+        bulkEditWithPrimitiveArrays: {
+          type: GraphQLString,
+          args: {
+            relatedEntitiesToAdd: { type: PrimitiveArrayInputType },
+            relatedEntitiesToRemove: { type: PrimitiveArrayInputType },
+            set: { type: SetInputType },
+          },
+        },
+      },
+    });
+
+    const schemaWithPrimitiveArrays = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: { dummy: { type: GraphQLString } },
+      }),
+      mutation: MutationTypeWithPrimitiveArrays,
+      types: [PrimitiveArrayInputType, SetInputType],
+    });
+
+    const result = plugin(schemaWithPrimitiveArrays, [], {}) as string;
+
+    // Check that the config is generated
+    expect(result).toContain('BulkEditWithPrimitiveArraysFormFieldsConfig');
+
+    // Check that list fields have "Add" and "Remove" postfixes
+    expect(result).toContain('"tagsAdd"');
+    expect(result).toContain('"tagsRemove"');
+    expect(result).toContain('"categoriesAdd"');
+    expect(result).toContain('"categoriesRemove"');
+
+    // Check labels
+    expect(result).toContain('"label": "Tags (Add)"');
+    expect(result).toContain('"label": "Tags (Remove)"');
+    expect(result).toContain('"label": "Categories (Add)"');
+    expect(result).toContain('"label": "Categories (Remove)"');
+
+    // Check that the type is correctly represented as array string type
+    expect(result).toContain('"type": "[String]"');
+    expect(result).toContain('"type": "[String!]"');
+
+    // Check actions
+    expect(result).toContain('"action": "relatedEntitiesToAdd"');
+    expect(result).toContain('"action": "relatedEntitiesToRemove"');
+
+    // Check original field names
+    expect(result).toContain('"originalFieldName": "tags"');
+    expect(result).toContain('"originalFieldName": "categories"');
+
+    // Verify the complete structure for one field
+    expect(result).toMatch(
+      /"tagsAdd":\s*\{\s*"type":\s*"\[String\]",\s*"label":\s*"Tags \(Add\)",\s*"originalFieldName":\s*"tags",\s*"action":\s*"relatedEntitiesToAdd"\s*\}/,
+    );
+  });
+
+  it('should handle list/array fields (tags) with composite types', () => {
+    // Create a schema with list fields similar to the imagesTags field
+    const TagInputType = new GraphQLInputObjectType({
+      name: 'TagInput',
+      fields: {
+        name: { type: new GraphQLNonNull(GraphQLString) },
+      },
+    });
+
+    const TagsInputType = new GraphQLInputObjectType({
+      name: 'TagsInput',
+      fields: {
+        tags: { type: new GraphQLList(TagInputType) },
+      },
+    });
+
+    const SetWithTagsInputType = new GraphQLInputObjectType({
+      name: 'SetWithTagsInput',
+      fields: {
+        title: { type: GraphQLString },
+      },
+    });
+
+    const MutationTypeWithTags = new GraphQLObjectType({
+      name: 'Mutation',
+      fields: {
+        bulkEditWithTags: {
+          type: GraphQLString,
+          args: {
+            relatedEntitiesToAdd: { type: TagsInputType },
+            relatedEntitiesToRemove: { type: TagsInputType },
+            set: { type: SetWithTagsInputType },
+          },
+        },
+      },
+    });
+
+    const schemaWithTags = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: { dummy: { type: GraphQLString } },
+      }),
+      mutation: MutationTypeWithTags,
+      types: [TagInputType, TagsInputType, SetWithTagsInputType],
+    });
+
+    const result = plugin(schemaWithTags, [], {}) as string;
+
+    // Check that the config is generated
+    expect(result).toContain('BulkEditWithTagsFormFieldsConfig');
+
+    // Check that list fields have "Add" and "Remove" postfixes
+    expect(result).toContain('"tagsAdd"');
+    expect(result).toContain('"tagsRemove"');
+
+    // Check labels
+    expect(result).toContain('"label": "Tags (Add)"');
+    expect(result).toContain('"label": "Tags (Remove)"');
+
+    // Check that the type is an array with composite type information
+    expect(result).toContain('"type": [');
+    expect(result).toContain('"name"');
+
+    // Check actions
+    expect(result).toContain('"action": "relatedEntitiesToAdd"');
+    expect(result).toContain('"action": "relatedEntitiesToRemove"');
+
+    // Check original field names
+    expect(result).toContain('"originalFieldName": "tags"');
+  });
+
   it('should generate config for mutations with only set argument', () => {
     const result = plugin(schema, [], {});
     expect(result).toContain('AnotherMutationFormFieldsConfig');
@@ -123,4 +332,48 @@ describe('generate-bulk-edit-ui-config plugin', () => {
     const result = plugin(schemaWithIrrelevantMutation, [], {});
     expect(result).not.toContain('NoRelevantArgsFormFieldsConfig');
   });
+
+  it('should handle errors gracefully and fall back to toString()', () => {
+    // Create a mock field type that will throw an error when accessing ofType
+    const ProblematicInputType = new GraphQLInputObjectType({
+      name: 'ProblematicInput',
+      fields: {
+        normalField: { type: GraphQLString },
+      },
+    });
+
+    const MutationTypeWithProblematic = new GraphQLObjectType({
+      name: 'Mutation',
+      fields: {
+        bulkEditProblematic: {
+          type: GraphQLString,
+          args: {
+            set: { type: ProblematicInputType },
+          },
+        },
+      },
+    });
+
+    const schemaWithProblematic = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: { dummy: { type: GraphQLString } },
+      }),
+      mutation: MutationTypeWithProblematic,
+      types: [ProblematicInputType],
+    });
+
+    // Spy on console.warn to verify it's called if needed
+    const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+    const result = plugin(schemaWithProblematic, [], {}) as string;
+
+    // Should still generate config even if there's an error
+    expect(result).toContain('BulkEditProblematicFormFieldsConfig');
+    expect(result).toContain('"normalField"');
+    expect(result).toContain('"type": "String"');
+
+    // Restore console.warn
+    consoleWarnSpy.mockRestore();
+  });
 });

package/src/generate-bulk-edit-ui-config/generate-bulk-edit-ui-config.ts

@@ -102,22 +102,29 @@ function resolveFields(
 
     let type: string | Data[] = field.type.toString();
 
-    if (Object.keys(field.type).includes('ofType')) {
-      const compositeType: Data[] = [];
-
-      Object.keys((field.type as GraphQLList<any>).ofType.getFields()).forEach(
-        (key) => {
-          const name = (field.type as GraphQLList<any>).ofType.getFields()[key]
-            .name;
-          const type = (field.type as GraphQLList<any>).ofType.getFields()[key]
-            .type;
-          compositeType.push({
-            [name]: type,
-          });
-        },
-      );
+    try {
+      // Handle list of composite types
+      const fields = (field.type as GraphQLList<any>).ofType?.getFields?.();
+
+      if (fields && typeof fields === 'object') {
+        const compositeType: Data = {};
+
+        Object.keys(fields).forEach((key) => {
+          const name = fields[key].name;
+          const type = fields[key].type;
+          compositeType[name] = type;
+        });
 
-      type = compositeType;
+        type = [compositeType];
+      }
+    } catch (error) {
+      // If we encounter an unknown type structure, fall back to toString()
+      // eslint-disable-next-line no-console
+      console.warn(
+        `Warning: Unable to resolve type structure for field "${fieldName}". Using toString() representation.`,
+        error,
+      );
+      type = field.type.toString();
     }
 
     resultingFields[postfix ? `${fieldName}${postfix}` : fieldName] = {