Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[Feature] Implment possiblity to hide interface fields on implementations #141

Open
wants to merge 2 commits into
base: main
Choose a base branch
from
Open

[Feature] Implment possiblity to hide interface fields on implementations #141

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
903d275
Implment possiblity to hide interface fields in object
matystl Dec 3, 2019
7c27d6f
Skip fields only if definition is same in interface and on object
matystl Dec 4, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,7 @@ module system it is exported as `GraphQLVoyager` global variable.
+ `displayOptions` _(optional)_
+ `displayOptions.skipRelay` [`boolean`, default `true`] - skip relay-related entities
+ `displayOptions.skipDeprecated` [`boolean`, default `true`] - skip deprecated fields and entities that contain only deprecated fields.
+ `displayOptions.skipInterfaceFields` [`boolean`, default `false`] - skip fields that are inherited from interface and have same definition
+ `displayOptions.rootType` [`string`] - name of the type to be used as a root
+ `displayOptions.sortByAlphabet` [`boolean`, default `false`] - sort fields on graph by alphabet
+ `displayOptions.showLeafFields` [`boolean`, default `true`] - show all scalars and enums
Expand Down
3 changes: 3 additions & 0 deletions src/components/Voyager.tsx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,6 +23,7 @@ export interface VoyagerDisplayOptions {
rootType?: string;
skipRelay?: boolean;
skipDeprecated?: boolean;
skipInterfaceFields?: boolean;
showLeafFields?: boolean;
sortByAlphabet?: boolean;
hideRoot?: boolean;
Expand All @@ -32,6 +33,7 @@ const defaultDisplayOptions = {
rootType: undefined,
skipRelay: true,
skipDeprecated: true,
skipInterfaceFields: false,
sortByAlphabet: false,
showLeafFields: true,
hideRoot: false,
Expand Down Expand Up @@ -130,6 +132,7 @@ export default class Voyager extends React.Component<VoyagerProps> {
displayOptions.sortByAlphabet,
displayOptions.skipRelay,
displayOptions.skipDeprecated,
displayOptions.skipInterfaceFields,
);
const typeGraph = getTypeGraph(schema, displayOptions.rootType, displayOptions.hideRoot);

Expand Down
7 changes: 7 additions & 0 deletions src/components/settings/Settings.tsx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -50,6 +50,13 @@ export default class Settings extends React.Component<SettingsProps> {
onChange={event => onChange({ showLeafFields: event.target.checked })}
/>
<label htmlFor="showLeafFields">Show leaf fields</label>
<Checkbox
id="skipInterfaceFields"
color="primary"
checked={!!options.skipInterfaceFields}
onChange={event => onChange({ skipInterfaceFields: event.target.checked })}
/>
<label htmlFor="skipInterfaceFields">Skip interface fields</label>
</div>
</div>
);
Expand Down
21 changes: 21 additions & 0 deletions src/graph/dot.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -77,6 +77,7 @@ export function getDot(typeGraph, displayOptions): string {
${objectValues(node.fields, nodeField)}
${possibleTypes(node)}
${derivedTypes(node)}
${interfacesTypes(node)}
</TABLE>>
`;
}
Expand Down Expand Up @@ -151,6 +152,26 @@ function derivedTypes(node) {
`;
}

function interfacesTypes(node) {
const interfacesTypes = node.interfaces;
if (_.isEmpty(interfacesTypes)) {
return '';
}
return `
<TR>
<TD>interfaces</TD>
</TR>
${array(
interfacesTypes,
({ id, type }) => `
<TR>
<TD ${HtmlId(id)} ALIGN="LEFT" PORT="${type.name}">${type.name}</TD>
</TR>
`,
)}
`;
}

function objectValues<X>(object: { [key: string]: X }, stringify: (X) => string): string {
return _.values(object)
.map(stringify)
Expand Down
6 changes: 6 additions & 0 deletions src/graph/svg-renderer.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -125,6 +125,12 @@ function preprocessVizSVG(svgString: string) {
$possibleType.querySelector('text').classList.add('type-link');
});

forEachNode(svg, '.interface', $interface => {
// not sure if next line should be here it works without it
// $interface.classList.add('edge-source');
$interface.querySelector('text').classList.add('type-link');
});

const serializer = new XMLSerializer();
return serializer.serializeToString(svg);
}
1 change: 1 addition & 0 deletions src/graph/type-graph.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,6 +20,7 @@ export function getTypeGraph(schema, rootType: string, hideRoot: boolean) {
..._.values(type.fields),
...(type.derivedTypes || []),
...(type.possibleTypes || []),
...(type.interfaces || []),
])
.map('type')
.filter(isNode)
Expand Down
46 changes: 45 additions & 1 deletion src/introspection/introspection.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -138,7 +138,7 @@ function markRelayTypes(schema: SimplifiedIntrospectionWithIds): void {
return;
}

const edgesType = connectionType.fields.edges.type
const edgesType = connectionType.fields.edges.type;
if (edgesType.kind !== 'OBJECT' || !edgesType.fields.node) {
return;
}
Expand Down Expand Up @@ -202,6 +202,46 @@ function markDeprecated(schema: SimplifiedIntrospectionWithIds): void {
// which are deprecated.
}

function markInterfaceFields(schema: SimplifiedIntrospectionWithIds): void {
function isFieldOnInterfaceSameAsOnType(objectField, interfaceField) {
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@IvanGoncharov added check that fields are same. I tested it manually with this schema

    interface IFoo {
      name: String
    }
    type Foo implements IFoo {
      name: String
    }
    type Bar {
      name: String
    }
    union FooAndBar = Foo | Bar

    # same types
    interface I0 {
      name: Foo
    }
    type Example0_hide implements I0 {
      name: Foo
    }

    # possible type of interface
    interface I1 {
      name: IFoo
    }
    type Example11_hide implements I1 {
      name: IFoo
    }
    type Example12 implements I1 {
      name: Foo
    }

    # possible type of union
    interface I2 {
      name: FooAndBar
    }
    type Example21_hide implements I2 {
      name: FooAndBar
    }
    type Example22 implements I2 {
      name: Foo
    }
    type Example23 implements I2 {
      name: Bar
    }

    # list subtyping
    interface I3 {
      name: [IFoo]
    }
    type Example31_hide implements I3 {
      name: [IFoo]
    }
    type Example32 implements I3 {
      name: [Foo]
    }

    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    # stricker nullability
    # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    # same types
    interface I4 {
      name: Foo
    }
    type Example4 implements I4 {
      name: Foo!
    }

    # possible type of interface
    interface I5 {
      name: IFoo
    }
    type Example51 implements I5 {
      name: IFoo!
    }
    type Example52 implements I5 {
      name: Foo!
    }

    # same union
    interface I6 {
      name: FooAndBar
    }
    type Example6 implements I6 {
      name: FooAndBar!
    }

    # possible type of union
    interface I7 {
      name: FooAndBar
    }
    type Example71 implements I7 {
      name: Foo!
    }
    type Example72 implements I7 {
      name: Bar!
    }

    # list subtyping
    interface I8 {
      name: [IFoo]
    }
    type Example81 implements I8 {
      name: [IFoo!]
    }
    type Example82 implements I8 {
      name: [Foo!]
    }
    type Example83 implements I8 {
      name: [IFoo]!
    }
    type Example84 implements I8 {
      name: [Foo]!
    }
    type Example85 implements I8 {
      name: [IFoo!]!
    }
    type Example86 implements I8 {
      name: [Foo!]!
    }

    # list subtyping 2
    interface I9 {
      name: [IFoo!]
    }
    type Example91_hide implements I9 {
      name: [IFoo!]
    }
    type Example92 implements I9 {
      name: [Foo!]
    }
    type Example93 implements I9 {
      name: [IFoo!]!
    }
    type Example94 implements I9 {
      name: [Foo!]!
    }

    # list subtyping 3
    interface I10 {
      name: [IFoo]!
    }
    type Example101_hide implements I10 {
      name: [IFoo]!
    }
    type Example102 implements I10 {
      name: [Foo]!
    }
    type Example103 implements I10 {
      name: [IFoo!]!
    }
    type Example104 implements I10 {
      name: [Foo!]!
    }

    # argument list
    interface I11 {
      name(some: String): Foo
    }
    type Example111_hide implements I11 {
      name(some: String): Foo
    }
    type Example112 implements I11 {
      name(some: String, aditionalArg:String): Foo
    }
    

    

    union Result =
        Example0_hide
      | Example11_hide
      | Example12
      | Example21_hide
      | Example22
      | Example23
      | Example31_hide
      | Example32
      | Example4
      | Example51
      | Example52
      | Example6
      | Example71
      | Example72
      | Example81
      | Example82
      | Example83
      | Example84
      | Example85
      | Example86
      | Example91_hide
      | Example92
      | Example93
      | Example94
      | Example101_hide
      | Example102
      | Example103
      | Example104
      | Example111_hide
      | Example112
      
    type Query {
      getFoo: Result
      getFooBar: FooAndBar
      # Get one todo item
    }

    type Mutation {
      addTodo(name: String!): String!
    }

    schema {
      query: Query
      mutation: Mutation
    }

// rules are described here https://graphql.github.io/graphql-spec/draft/#sel-HAHZhCFHABABiCp7I
// we don't need to check for everything as valid rules are enforeced at time of parsing schema

if (objectField.type.id !== interfaceField.type.id) {
// return type of field is not same as in parrent
// this case also take care of types wrapped in lists or not null modificator
return false;
}
if (objectField.typeWrappers.length !== interfaceField.typeWrappers.length) {
// return type has stricker nullability modificator
// list modifier could not be changed as it would be parse error
return false;
}
if (_.keys(objectField.args).length !== _.keys(interfaceField.args).length) {
// if there are any aditional args they are not same
return false;
}
return true;
}
_.each(schema.types, type => {
if (type.kind === 'OBJECT') {
if (type.interfaces && type.interfaces.length > 0) {
// we have some interfaces for this object
// so we should delete fields that are presented in interface
// and also present in object and are same

_.each(type.interfaces, oneInterface => {
_.each(oneInterface.type.fields, interfaceField => {
if (isFieldOnInterfaceSameAsOnType(type.fields[interfaceField.name], interfaceField)) {
delete type.fields[interfaceField.name];
}
});
});
}
}
});
}

function assignTypesAndIDs(schema: SimplifiedIntrospection) {
(<any>schema).queryType = schema.types[schema.queryType];
(<any>schema).mutationType = schema.types[schema.mutationType];
Expand Down Expand Up @@ -254,6 +294,7 @@ export function getSchema(
sortByAlphabet: boolean,
skipRelay: boolean,
skipDeprecated: boolean,
skipInterfaceFields: boolean,
) {
if (!introspection) return null;

Expand All @@ -273,5 +314,8 @@ export function getSchema(
if (skipDeprecated) {
markDeprecated((<any>simpleSchema) as SimplifiedIntrospectionWithIds);
}
if (skipInterfaceFields) {
markInterfaceFields((<any>simpleSchema) as SimplifiedIntrospectionWithIds);
}
return simpleSchema;
}