@axinom/mosaic-graphql-codegen-plugins 0.2.0-rc.0

package/README.md

@@ -0,0 +1,16 @@
+# @axinom/mosaic-graphql-codegen-plugins
+
+## About the Package
+
+This package is part of the Axinom Mosaic development platform. More information
+can be found at https://portal.axinom.com/mosaic.
+
+## License
+
+This package can be licensed under the
+[Axinom Products Licensing Agreement](https://portal.axinom.com/mosaic/contracts/products-licensing-agreement)
+or evaluated under the
+[Axinom Products Evaluation Agreement](https://portal.axinom.com/mosaic/contracts/products-evaluation-agreement).  
+No part of Axinom's software may be copied, modified, propagated, or distributed
+except in accordance with the terms contained in the Axinom Products Licensing
+Agreement and Axinom Products Evaluation Agreement.

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@axinom/mosaic-graphql-codegen-plugins",
+  "version": "0.2.0-rc.0",
+  "description": "Library of graphql-codegen plugins for Mosaic workflows",
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "yarn clean && tsc --project tsconfig.build.json",
+    "test": "jest --silent",
+    "lint": "eslint . --ext .ts,.tsx,.js --color --cache"
+  },
+  "author": "Axinom",
+  "license": "PROPRIETARY",
+  "keywords": [
+    "axinom",
+    "mosaic",
+    "axinom mosaic"
+  ],
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    "./generate-enum-comments": "./dist/generate-enum-comments/generate-enum-comments.js",
+    "./generate-bulk-edit-ui-config": "./dist/generate-bulk-edit-ui-config/generate-bulk-edit-ui-config.js"
+  },
+  "dependencies": {
+    "change-case-all": "^2.1.0",
+    "handlebars": "^4.7.7"
+  },
+  "devDependencies": {
+    "@graphql-codegen/plugin-helpers": "^5.1.1",
+    "jest": "^29",
+    "rimraf": "^3.0.2",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "peerDependencies": {
+    "graphql": "^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "4d2dbe509438f1c3220e7bbc4aaba013da327d67"
+}

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

@@ -0,0 +1,126 @@
+import {
+  GraphQLInputObjectType,
+  GraphQLObjectType,
+  GraphQLSchema,
+  GraphQLString,
+} from 'graphql';
+import { BulkEditPluginConfig, plugin } from './generate-bulk-edit-ui-config';
+
+describe('generate-bulk-edit-ui-config plugin', () => {
+  let schema: GraphQLSchema;
+
+  beforeEach(() => {
+    const RelatedEntitiesInputType = new GraphQLInputObjectType({
+      name: 'RelatedEntitiesInput',
+      fields: {
+        id: { type: GraphQLString },
+        name: { type: GraphQLString },
+      },
+    });
+
+    const SetInputType = new GraphQLInputObjectType({
+      name: 'SetInput',
+      fields: {
+        status: { type: GraphQLString },
+      },
+    });
+
+    const MutationType = new GraphQLObjectType({
+      name: 'Mutation',
+      fields: {
+        bulkEditEntity: {
+          type: GraphQLString,
+          args: {
+            relatedEntitiesToAdd: { type: RelatedEntitiesInputType },
+            relatedEntitiesToRemove: { type: RelatedEntitiesInputType },
+            set: { type: SetInputType },
+          },
+        },
+        anotherMutation: {
+          type: GraphQLString,
+          args: {
+            set: { type: SetInputType },
+          },
+        },
+      },
+    });
+
+    const QueryType = new GraphQLObjectType({
+      name: 'Query',
+      fields: {
+        dummy: { type: GraphQLString },
+      },
+    });
+
+    schema = new GraphQLSchema({
+      query: QueryType,
+      mutation: MutationType,
+      types: [RelatedEntitiesInputType, SetInputType],
+    });
+  });
+
+  it('should generate config for mutations with relatedEntitiesToAdd, relatedEntitiesToRemove, and set', () => {
+    const result = plugin(schema, [], {});
+    expect(result).toContain('BulkEditEntityFormFieldsConfig');
+    expect(result).toContain('relatedEntitiesToAdd');
+    expect(result).toContain('relatedEntitiesToRemove');
+    expect(result).toContain('set');
+    expect(result).toContain('fields');
+    expect(result).toContain('mutation');
+  });
+
+  it('should generate config for mutations with only set argument', () => {
+    const result = plugin(schema, [], {});
+    expect(result).toContain('AnotherMutationFormFieldsConfig');
+    expect(result).toContain('set');
+    expect(result).toContain('fields');
+  });
+
+  it('should use custom keys from config', () => {
+    const customConfig: Partial<BulkEditPluginConfig> = {
+      addKey: 'customAdd',
+      removeKey: 'customRemove',
+      setKey: 'customSet',
+      filterKey: 'customFilter',
+    };
+    const result = plugin(schema, [], customConfig);
+    expect(result).toContain('customAdd');
+    expect(result).toContain('customRemove');
+    expect(result).toContain('customSet');
+    expect(result).toContain('customFilter');
+  });
+
+  it('should return empty string if mutationType or queryType is missing', () => {
+    const schemaWithoutMutation = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: { dummy: { type: GraphQLString } },
+      }),
+    });
+    const result = plugin(schemaWithoutMutation, [], {});
+    expect(result).toBe('');
+  });
+
+  it('should not generate config if mutation has no relevant args', () => {
+    const MutationType = new GraphQLObjectType({
+      name: 'Mutation',
+      fields: {
+        noRelevantArgs: {
+          type: GraphQLString,
+          args: {
+            irrelevant: { type: GraphQLString },
+          },
+        },
+      },
+    });
+    const schemaWithIrrelevantMutation = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: { dummy: { type: GraphQLString } },
+      }),
+      mutation: MutationType,
+    });
+    const result = plugin(schemaWithIrrelevantMutation, [], {});
+    expect(result).not.toContain('NoRelevantArgsFormFieldsConfig');
+  });
+});

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

@@ -0,0 +1,134 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { PluginFunction } from '@graphql-codegen/plugin-helpers';
+import { capitalCase, pascalCase } from 'change-case-all';
+import { GraphQLFieldMap, GraphQLList, GraphQLObjectType } from 'graphql';
+
+export interface BulkEditPluginConfig {
+  addKey?: string;
+  removeKey?: string;
+  setKey?: string;
+  filterKey?: string;
+}
+
+interface Data {
+  [key: string]: unknown;
+}
+
+export const plugin: PluginFunction<Partial<BulkEditPluginConfig>> = (
+  schema,
+  _documents,
+  config,
+) => {
+  const addKey = config.addKey || 'relatedEntitiesToAdd';
+  const removeKey = config.removeKey || 'relatedEntitiesToRemove';
+  const setKey = config.setKey || 'set';
+  const filterKey = config.filterKey || 'filter';
+
+  const mutationType = schema.getMutationType();
+  const queryType = schema.getQueryType();
+
+  if (!mutationType || !queryType) {
+    // eslint-disable-next-line no-console
+    console.warn('No mutation type or query type found in schema');
+    return '';
+  }
+
+  const typesMap = schema.getTypeMap();
+
+  const mutations = mutationType.getFields();
+  const configs = Object.keys(mutations).map((mutationName) => {
+    const mutation = mutations[mutationName];
+
+    let formFieldsConfig = {};
+
+    mutation.args.map((arg) => {
+      switch (arg.name.toString()) {
+        case 'relatedEntitiesToAdd':
+          formFieldsConfig = {
+            ...formFieldsConfig,
+            ...resolveFields(
+              (typesMap[arg.type.toString()] as GraphQLObjectType).getFields(),
+              addKey,
+              'Add',
+            ),
+          };
+          break;
+        case 'relatedEntitiesToRemove':
+          formFieldsConfig = {
+            ...formFieldsConfig,
+            ...resolveFields(
+              (typesMap[arg.type.toString()] as GraphQLObjectType).getFields(),
+              removeKey,
+              'Remove',
+            ),
+          };
+          break;
+        case 'set':
+          formFieldsConfig = {
+            ...formFieldsConfig,
+            ...resolveFields(
+              (typesMap[arg.type.toString()] as GraphQLObjectType).getFields(),
+              setKey,
+            ),
+          };
+          break;
+      }
+    });
+
+    if (Object.keys(formFieldsConfig).length > 0) {
+      return `export const ${pascalCase(
+        mutationName,
+      )}FormFieldsConfig = { mutation: '${mutationName}', keys: { add: '${addKey}', remove: '${removeKey}', set: '${setKey}', filter: '${filterKey}' }, fields: ${JSON.stringify(
+        formFieldsConfig,
+        null,
+        2,
+      )}};`;
+    }
+  });
+
+  return ['/** Bulk Edit Configurations **/', ...configs]
+    .filter((config) => config !== null && config !== undefined)
+    .join('\n');
+};
+
+function resolveFields(
+  fields: GraphQLFieldMap<any, any>,
+  action: string,
+  postfix = '',
+): Data {
+  const resultingFields: Data = {};
+  Object.keys(fields).map((fieldName) => {
+    const field = fields[fieldName];
+
+    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,
+          });
+        },
+      );
+
+      type = compositeType;
+    }
+
+    resultingFields[postfix ? `${fieldName}${postfix}` : fieldName] = {
+      type: type,
+      label: postfix
+        ? `${capitalCase(fieldName)} (${postfix})`
+        : capitalCase(fieldName),
+      originalFieldName: fieldName,
+      action: action,
+    };
+  });
+
+  return resultingFields;
+}

package/src/generate-enum-comments/generate-enum-comments.spec.ts

@@ -0,0 +1,185 @@
+import { buildSchema } from 'graphql';
+import { plugin } from './generate-enum-comments';
+
+describe('generate-enum-comments plugin', () => {
+  describe('plugin function', () => {
+    it('should generate enum labels for enums with descriptions', () => {
+      const schema = buildSchema(`
+        enum Status {
+          """Active status"""
+          ACTIVE
+          """Inactive status"""
+          INACTIVE
+          """Pending status"""
+          PENDING
+        }
+      `);
+
+      const result = plugin(schema, [], {}, { outputFile: '' });
+
+      expect(result).toContain('export const StatusLabel');
+      expect(result).toContain("'ACTIVE' : 'Active status'");
+      expect(result).toContain("'INACTIVE' : 'Inactive status'");
+      expect(result).toContain("'PENDING' : 'Pending status'");
+    });
+
+    it('should handle enums with mixed descriptions', () => {
+      const schema = buildSchema(`
+        enum Priority {
+          """High priority task"""
+          HIGH
+          MEDIUM
+          """Low priority task"""
+          LOW
+        }
+      `);
+
+      const result = plugin(schema, [], {}, { outputFile: '' });
+
+      expect(result).toContain('export const PriorityLabel');
+      expect(result).toContain("'HIGH' : 'High priority task'");
+      expect(result).not.toContain("'MEDIUM' :");
+      expect(result).toContain("'LOW' : 'Low priority task'");
+    });
+
+    it('should handle enums without descriptions', () => {
+      const schema = buildSchema(`
+        enum Color {
+          RED
+          GREEN
+          BLUE
+        }
+      `);
+
+      const result = plugin(schema, [], {}, { outputFile: '' });
+
+      expect(result).toContain('export const ColorLabel');
+      expect(result).not.toContain("'RED' :");
+      expect(result).not.toContain("'GREEN' :");
+      expect(result).not.toContain("'BLUE' :");
+    });
+
+    it('should handle multiple enums', () => {
+      const schema = buildSchema(`
+        enum Status {
+          """Active"""
+          ACTIVE
+          """Inactive"""
+          INACTIVE
+        }
+        
+        enum Role {
+          """Administrator role"""
+          ADMIN
+          """User role"""
+          USER
+        }
+      `);
+
+      const result = plugin(schema, [], {}, { outputFile: '' });
+
+      expect(result).toContain('export const StatusLabel');
+      expect(result).toContain('export const RoleLabel');
+      expect(result).toContain("'ACTIVE' : 'Active'");
+      expect(result).toContain("'ADMIN' : 'Administrator role'");
+    });
+
+    it('should filter out internal GraphQL types', () => {
+      const schema = buildSchema(`
+        enum Status {
+          ACTIVE
+          INACTIVE
+        }
+      `);
+
+      const result = plugin(schema, [], {}, { outputFile: '' });
+
+      expect(result).toContain('export const StatusLabel');
+      expect(result).not.toContain('__Schema');
+      expect(result).not.toContain('__Type');
+      expect(result).not.toContain('__Directive');
+    });
+
+    it('should handle descriptions with quotes and whitespace', () => {
+      const schema = buildSchema(`
+        enum Status {
+          """This is a 'quoted' description with   multiple    spaces"""
+          ACTIVE
+        }
+      `);
+
+      const result = plugin(schema, [], {}, { outputFile: '' });
+
+      expect(result).toContain(
+        "'ACTIVE' : 'This is a \\'quoted\\' description with multiple spaces'",
+      );
+    });
+
+    it('should generate proxy handler code', () => {
+      const schema = buildSchema(`
+        enum Status {
+          ACTIVE
+        }
+      `);
+
+      const result = plugin(schema, [], {}, { outputFile: '' });
+
+      expect(result).toContain('const getWithFallbackHandler');
+      expect(result).toContain('ProxyHandler');
+      expect(result).toContain('new Proxy');
+      expect(result).toContain('getWithFallbackHandler');
+    });
+
+    it('should handle empty schema', () => {
+      const schema = buildSchema(`
+        type Query {
+          hello: String
+        }
+      `);
+
+      const result = plugin(schema, [], {}, { outputFile: '' });
+
+      expect(result).toContain('/** generate-enum-comments **/');
+      expect(result).toContain('const getWithFallbackHandler');
+      expect(result).not.toContain('export const');
+    });
+
+    it('should handle schema with only scalar and object types', () => {
+      const schema = buildSchema(`
+        type User {
+          id: ID!
+          name: String!
+        }
+        
+        type Query {
+          user: User
+        }
+      `);
+
+      const result = plugin(schema, [], {}, { outputFile: '' });
+
+      expect(result).toContain('/** generate-enum-comments **/');
+      expect(result).not.toContain('export const');
+    });
+
+    it('should generate valid TypeScript code structure', () => {
+      const schema = buildSchema(`
+        enum Status {
+          """Active status"""
+          ACTIVE
+        }
+      `);
+
+      const result = plugin(schema, [], {}, { outputFile: '' });
+
+      // Check for proper TypeScript syntax
+      expect(result).toMatch(
+        /export const \w+Label = new Proxy<Record<string,string>>/,
+      );
+      expect(result).toContain(
+        'ProxyHandler<{ [key: string | symbol]: string}>',
+      );
+      expect(result).toContain('target.hasOwnProperty(name)');
+    });
+  });
+});

package/src/generate-enum-comments/generate-enum-comments.ts

@@ -0,0 +1,51 @@
+import { PluginFunction, Types } from '@graphql-codegen/plugin-helpers';
+import { GraphQLNamedType, GraphQLSchema } from 'graphql';
+import handlebars from 'handlebars';
+
+handlebars.registerHelper('jsonSafe', (/** @type {String} */ value) => {
+  return value.replace(/'/g, "\\'").replace(/\s+/g, ' ');
+});
+
+const template = handlebars.compile(`
+/** generate-enum-comments **/
+const getWithFallbackHandler: ProxyHandler<{ [key: string | symbol]: string}> = {
+  get: function(target, name) {
+    return target.hasOwnProperty(name) ? target[name] : name;
+  }
+};
+{{#each enums}}
+
+export const {{{name}}}Label = new Proxy<Record<string,string>>({
+  {{#each _values}}
+    {{#if description}}
+    '{{{name}}}' : '{{{jsonSafe description}}}',
+    {{/if}}
+  {{/each}}
+}, getWithFallbackHandler);
+{{/each}}
+`);
+
+function getEnumTypeMap(schema: GraphQLSchema): GraphQLNamedType[] {
+  const typeMap = schema.getTypeMap();
+  const result: GraphQLNamedType[] = [];
+  for (const typeName in typeMap) {
+    const type = typeMap[typeName];
+    if (
+      type.constructor.name === 'GraphQLEnumType' &&
+      !typeName.startsWith('__') // Filter out internal types
+    ) {
+      result.push(type);
+    }
+  }
+  return result;
+}
+
+export const plugin: PluginFunction<Types.ConfiguredOutput> = (schema) => {
+  const enums = getEnumTypeMap(schema);
+
+  const result = template({
+    enums,
+  });
+
+  return result;
+};