Merge remote-tracking branch 'origin/dev' into group-by

Author: angrykoala

.changeset/chilly-grapes-rest.md

@@ -0,0 +1,20 @@
+---
+"@neo4j/graphql": minor
+---
+
+Add support for single element relationships. For example:
+
+```graphql
+type Movie @node {
+    title: String!
+    actor: [Actor!]! @relationship(type: "ACTED_IN", direction: IN, properties: "ActedIn")
+    director: Director! @relationship(type: "DIRECTED", direction: IN, properties: "Directed")
+}
+```
+
+It makes possible to model and query the data of single element relationships, with the following constraints:
+
+- If multiple relationships exists, the first one will be returned. The relationship that will be returned will not be guaranteed
+- Connections will maintain the many-to-many API, even if it is a single relationship. This is to maintain the relay spec
+- Delete mutations will be available for nullable fields
+- Create mutations will be available for both, nullable and non-nullable

packages/graphql/src/schema-model/entity/model-adapters/ConcreteEntityAdapter.ts

@@ -153,6 +153,7 @@ export class ConcreteEntityAdapter {
 
     public get relatedEntities(): EntityAdapter[] {
         if (!this._relatedEntities) {
+            // TODO: remove array destructuring with Node 20
             this._relatedEntities = [...this.relationships.values()].map((relationship) => relationship.target);
         }
         return this._relatedEntities;
@@ -268,6 +269,11 @@ export class ConcreteEntityAdapter {
         return this.relationships.get(name);
     }
 
+    public hasListRelationship(): boolean {
+        // TODO: remove array destructuring with Node 20
+        return !![...this.relationships.values()].find((r) => r.isList);
+    }
+
     // TODO: identify usage of old Node.[getLabels | getLabelsString] and migrate them if needed
     public getLabels(): string[] {
         return Array.from(this.labels);

packages/graphql/src/schema/create-relationship-fields/create-relationship-fields.ts

@@ -192,12 +192,6 @@ export function createRelationshipFields({
             return;
         }
 
-        if (!relationshipAdapter.isList) {
-            throw new Error(
-                `@relationship on non-list field [${relationshipAdapter.source.name}.${relationshipAdapter.name}] not supported`
-            );
-        }
-
         // TODO: find a way to merge these 2 into 1 RelationshipProperties generation function
         if (relationshipAdapter instanceof RelationshipDeclarationAdapter) {
             doForRelationshipDeclaration({
@@ -334,13 +328,6 @@ function createRelationshipFieldsForTarget({
         )
     );
 
-    withRelationInputType({
-        relationshipAdapter,
-        composer,
-        deprecatedDirectives,
-        userDefinedFieldDirectives,
-    });
-
     augmentCreateInputTypeWithRelationshipsInput({
         relationshipAdapter,
         composer,
@@ -349,31 +336,40 @@ function createRelationshipFieldsForTarget({
         features,
     });
 
-    augmentConnectInputTypeWithConnectFieldInput({
-        relationshipAdapter,
-        composer,
-        deprecatedDirectives,
-    });
-
     augmentDeleteInputTypeWithDeleteFieldInput({
         relationshipAdapter,
         composer,
         deprecatedDirectives,
         features,
     });
 
-    augmentDisconnectInputTypeWithDisconnectFieldInput({
-        relationshipAdapter,
-        composer,
-        deprecatedDirectives,
-        features,
-    });
+    if (relationshipAdapter.isList) {
+        withRelationInputType({
+            relationshipAdapter,
+            composer,
+            deprecatedDirectives,
+            userDefinedFieldDirectives,
+        });
 
-    augmentUpdateInputTypeWithUpdateFieldInput({
-        relationshipAdapter,
-        composer,
-        deprecatedDirectives,
-        userDefinedFieldDirectives,
-        features,
-    });
+        augmentConnectInputTypeWithConnectFieldInput({
+            relationshipAdapter,
+            composer,
+            deprecatedDirectives,
+        });
+
+        augmentDisconnectInputTypeWithDisconnectFieldInput({
+            relationshipAdapter,
+            composer,
+            deprecatedDirectives,
+            features,
+        });
+
+        augmentUpdateInputTypeWithUpdateFieldInput({
+            relationshipAdapter,
+            composer,
+            deprecatedDirectives,
+            userDefinedFieldDirectives,
+            features,
+        });
+    }
 }

packages/graphql/src/schema/generation/augment-object-or-interface.ts

@@ -61,6 +61,10 @@ export function augmentObjectOrInterfaceTypeWithRelationshipField({
         }
     }
 
+    if (!relationshipAdapter.isList) {
+        generateRelFieldArgs = false;
+    }
+
     if (generateRelFieldArgs) {
         const relationshipTarget =
             relationshipAdapter instanceof RelationshipAdapter && relationshipAdapter.originalTarget
@@ -71,9 +75,11 @@ export function augmentObjectOrInterfaceTypeWithRelationshipField({
 
         const nodeFieldsArgs = {
             where: whereTypeName,
-            limit: features?.limitRequired ? new GraphQLNonNull(GraphQLInt) : GraphQLInt,
-            offset: GraphQLInt,
         };
+
+        nodeFieldsArgs["limit"] = features?.limitRequired ? new GraphQLNonNull(GraphQLInt) : GraphQLInt;
+        nodeFieldsArgs["offset"] = GraphQLInt;
+
         if (!(relationshipTarget instanceof UnionEntityAdapter)) {
             const sortConfig = makeSortInput({
                 entityAdapter: relationshipTarget,
@@ -107,24 +113,30 @@ export function augmentObjectOrInterfaceTypeWithConnectionField(
         )
     );
 
-    const composeNodeArgs: ObjectTypeComposerArgumentConfigMapDefinition = {
-        where: makeConnectionWhereInputType({
-            relationshipAdapter,
-            composer: schemaComposer,
-        }),
-        first: {
-            type: features?.limitRequired ? new GraphQLNonNull(GraphQLInt) : GraphQLInt,
-        },
-        after: {
-            type: GraphQLString,
-        },
-    };
-    const connectionSortITC = withConnectionSortInputType({
+    const composeNodeArgs: ObjectTypeComposerArgumentConfigMapDefinition = {};
+
+    // we want this type to be created for single relationships, but don't want to set the argument
+    const connectionWhereInput = makeConnectionWhereInputType({
         relationshipAdapter,
         composer: schemaComposer,
     });
-    if (connectionSortITC) {
-        composeNodeArgs.sort = connectionSortITC.NonNull.List;
+
+    if (relationshipAdapter.isList) {
+        composeNodeArgs.where = connectionWhereInput;
+        composeNodeArgs.first = {
+            type: features?.limitRequired ? new GraphQLNonNull(GraphQLInt) : GraphQLInt,
+        };
+        composeNodeArgs.after = {
+            type: GraphQLString,
+        };
+
+        const connectionSortITC = withConnectionSortInputType({
+            relationshipAdapter,
+            composer: schemaComposer,
+        });
+        if (connectionSortITC) {
+            composeNodeArgs.sort = connectionSortITC.NonNull.List;
+        }
     }
     const isTargetUnion = relationshipAdapter.target instanceof UnionEntityAdapter;
     const isSourceInterface = relationshipAdapter.source instanceof InterfaceEntityAdapter;

packages/graphql/src/schema/generation/augment-where-input.ts

@@ -50,6 +50,19 @@ export function augmentWhereInputWithRelationshipFilters({
     deprecatedDirectives: Directive[];
     features?: Neo4jFeaturesSettings;
 }) {
+    if (!relationshipAdapter.isList) {
+        whereInput.addFields({
+            [relationshipAdapter.name]: {
+                type: relationshipAdapter.target.operations.whereInputTypeName,
+            },
+        });
+        whereInput.addFields({
+            [relationshipAdapter.operations.connectionFieldName]: {
+                type: relationshipAdapter.operations.getConnectionWhereTypename(),
+            },
+        });
+        return {};
+    }
     if (!relationshipAdapter.isFilterableByAggregate() && !relationshipAdapter.isFilterableByValue()) {
         return {};
     }

packages/graphql/src/schema/generation/connect-input.ts

@@ -41,6 +41,9 @@ function withConnectInputType({
     composer: SchemaComposer;
 }): InputTypeComposer | undefined {
     if (entityAdapter instanceof ConcreteEntityAdapter) {
+        if (!entityAdapter.hasListRelationship()) {
+            return undefined;
+        }
         return composer.getOrCreateITC(entityAdapter.operations.connectInputTypeName);
     }
 
@@ -194,9 +197,14 @@ export function withConnectFieldInputType({
         return composer.getITC(typeName);
     }
 
+    const fields = makeConnectFieldInputTypeFields({ relationshipAdapter, composer, ifUnionMemberEntity });
+    if (!relationshipAdapter.isList) {
+        return undefined;
+    }
+
     const connectFieldInput = composer.createInputTC({
         name: typeName,
-        fields: makeConnectFieldInputTypeFields({ relationshipAdapter, composer, ifUnionMemberEntity }),
+        fields,
     });
     return connectFieldInput;
 }

packages/graphql/src/schema/generation/connection-object-type.ts

@@ -51,7 +51,7 @@ export function withConnectionObjectType({
     const isTargetUnion = relationshipAdapter.target instanceof UnionEntityAdapter;
     const isSourceInterface = relationshipAdapter.source instanceof InterfaceEntityAdapter;
 
-    if (relationshipAdapter.aggregate && !isTargetUnion && !isSourceInterface) {
+    if (relationshipAdapter.isList && relationshipAdapter.aggregate && !isTargetUnion && !isSourceInterface) {
         const connectionObjectType = composer.getOrCreateOTC(typeName);
         connectionObjectType.addFields({
             aggregate: composer.getOTC(relationshipAdapter.operations.getAggregateFieldTypename()).NonNull,

packages/graphql/src/schema/generation/disconnect-input.ts

@@ -42,6 +42,9 @@ function withDisconnectInputType({
     composer: SchemaComposer;
 }): InputTypeComposer | undefined {
     if (entityAdapter instanceof ConcreteEntityAdapter) {
+        if (!entityAdapter.hasListRelationship()) {
+            return undefined;
+        }
         return composer.getOrCreateITC(entityAdapter.operations.updateMutationArgumentNames.disconnect);
     }
 

packages/graphql/src/schema/generation/relation-input.ts

@@ -202,14 +202,18 @@ export function withCreateFieldInputType({
     if (composer.has(createName)) {
         return composer.getITC(createName);
     }
+    const fields = makeCreateFieldInputTypeFields({
+        relationshipAdapter,
+        composer,
+        ifUnionMemberEntity,
+        userDefinedFieldDirectives,
+    });
+    if (!Object.keys(fields).length) {
+        return undefined;
+    }
     const createFieldInput = composer.createInputTC({
         name: createName,
-        fields: makeCreateFieldInputTypeFields({
-            relationshipAdapter,
-            composer,
-            ifUnionMemberEntity,
-            userDefinedFieldDirectives,
-        }),
+        fields,
     });
     return createFieldInput;
 }

packages/graphql/src/schema/generation/where-input.ts

@@ -195,7 +195,7 @@ export function withSourceWhereInputType({
         return;
     }
 
-    if (relationshipAdapter.isFilterableByAggregate()) {
+    if (relationshipAdapter.isList && relationshipAdapter.isFilterableByAggregate()) {
         withConnectionAggregateInputType({
             relationshipAdapter,
             entityAdapter: relationshipTarget,