Merge remote-tracking branch 'upstream/dev' into 7.x

neo4j · Jan 13, 2025 · b0d8882 · b0d8882
2 parents 188a767 + fd3f015
commit b0d8882
Show file tree

Hide file tree

Showing 8 changed files with 121 additions and 67 deletions.
diff --git a/.changeset/beige-beds-push.md b/.changeset/beige-beds-push.md
@@ -0,0 +1,13 @@
+---
+"@neo4j/graphql": patch
+---
+
+Aggregations on ID fields are now deprecated.
+As part of the change, the flag `idAggregations` has been added to the `excludeDeprecatedFields` setting.
+
+```js
+const neoSchema = new Neo4jGraphQL({
+    typeDefs,
+    features: { excludeDeprecatedFields: { idAggregations: true } },
+});
+```
diff --git a/.changeset/fluffy-schools-promise.md b/.changeset/fluffy-schools-promise.md
@@ -0,0 +1,13 @@
+---
+"@neo4j/graphql": minor
+---
+
+Introduced the `typename` filter that superseded the `typename_IN` filter. 
+As part of the change, the flag `typename_IN` has been added to the `excludeDeprecatedFields` setting.
+
+```js
+const neoSchema = new Neo4jGraphQL({
+    typeDefs,
+    features: { excludeDeprecatedFields: { typename_IN: true } },
+});
+```
diff --git a/packages/graphql/src/schema/aggregations/aggregation-types-mapper.ts b/packages/graphql/src/schema/aggregations/aggregation-types-mapper.ts
@@ -50,7 +50,7 @@ export class AggregationTypesMapper {
             resolve: numericalResolver,
             args: {},
         };
-
+        // TODO: REMOVE ID FIELD ON 7.x
         const composeId = {
             type: "ID",
             resolve: idResolver,
@@ -64,6 +64,7 @@ export class AggregationTypesMapper {
             fields?: Record<string, any>;
             directives?: string[];
         }> = [
+            // TODO: REMOVE ID FIELD ON 7.x
             {
                 name: "ID",
                 fields: {
@@ -140,6 +141,7 @@ export class AggregationTypesMapper {
     }): ObjectTypeComposer<any, any> {
         return composer.getOrCreateOTC(`${name}AggregateSelection`, (tc) => {
             tc.addFields(fields ?? { min: name, max: name });
+
             for (const directive of directives) {
                 tc.setDirectiveByName(directive);
             }

diff --git a/packages/graphql/src/schema/aggregations/field-aggregation-composer.ts b/packages/graphql/src/schema/aggregations/field-aggregation-composer.ts
@@ -18,13 +18,14 @@
  */
 
 import { GraphQLInt, GraphQLNonNull } from "graphql";
-import type { ObjectTypeComposer, SchemaComposer } from "graphql-compose";
+import type { ObjectTypeComposer, ObjectTypeComposerFieldConfigMapDefinition, SchemaComposer } from "graphql-compose";
 import type { Subgraph } from "../../classes/Subgraph";
 import type { ConcreteEntityAdapter } from "../../schema-model/entity/model-adapters/ConcreteEntityAdapter";
 import type { InterfaceEntityAdapter } from "../../schema-model/entity/model-adapters/InterfaceEntityAdapter";
 import { UnionEntityAdapter } from "../../schema-model/entity/model-adapters/UnionEntityAdapter";
 import { RelationshipAdapter } from "../../schema-model/relationship/model-adapters/RelationshipAdapter";
 import type { RelationshipDeclarationAdapter } from "../../schema-model/relationship/model-adapters/RelationshipDeclarationAdapter";
+import type { Neo4jFeaturesSettings } from "../../types";
 import { numericalResolver } from "../resolvers/field/numerical";
 import { AggregationTypesMapper } from "./aggregation-types-mapper";
 
@@ -39,29 +40,28 @@ export class FieldAggregationComposer {
 
     private createAggregationField(
         name: string,
-        fields: Record<string, ObjectTypeComposer>
+        fields: ObjectTypeComposerFieldConfigMapDefinition<any, any>
     ): ObjectTypeComposer | undefined {
         if (Object.keys(fields).length > 0) {
             return this.composer.createObjectTC({
                 name,
-                fields: {
-                    ...fields,
-                },
+                fields,
             });
         }
         return undefined;
     }
 
     public createAggregationTypeObject(
-        relationshipAdapter: RelationshipAdapter | RelationshipDeclarationAdapter
+        relationshipAdapter: RelationshipAdapter | RelationshipDeclarationAdapter,
+        features: Neo4jFeaturesSettings | undefined
     ): ObjectTypeComposer {
         let aggregateSelectionEdge: ObjectTypeComposer | undefined;
 
         if (relationshipAdapter.target instanceof UnionEntityAdapter) {
             throw new Error("UnionEntityAdapter not implemented");
         }
 
-        const aggregateSelectionNodeFields = this.getAggregationFields(relationshipAdapter.target);
+        const aggregateSelectionNodeFields = this.getAggregationFields(relationshipAdapter.target, features);
         const aggregateSelectionNodeName = relationshipAdapter.operations.getAggregationFieldTypename("node");
 
         const aggregateSelectionNode = this.createAggregationField(
@@ -70,7 +70,7 @@ export class FieldAggregationComposer {
         );
 
         if (relationshipAdapter instanceof RelationshipAdapter && relationshipAdapter.attributes.size > 0) {
-            const aggregateSelectionEdgeFields = this.getAggregationFields(relationshipAdapter);
+            const aggregateSelectionEdgeFields = this.getAggregationFields(relationshipAdapter, features);
             const aggregateSelectionEdgeName = relationshipAdapter.operations.getAggregationFieldTypename("edge");
 
             aggregateSelectionEdge = this.createAggregationField(
@@ -94,13 +94,19 @@ export class FieldAggregationComposer {
     }
 
     private getAggregationFields(
-        entity: RelationshipAdapter | ConcreteEntityAdapter | InterfaceEntityAdapter
-    ): Record<string, ObjectTypeComposer> {
+        entity: RelationshipAdapter | ConcreteEntityAdapter | InterfaceEntityAdapter,
+        _features: Neo4jFeaturesSettings | undefined
+    ): ObjectTypeComposerFieldConfigMapDefinition<any, any> {
         return entity.aggregableFields.reduce((res, field) => {
             const objectTypeComposer = this.aggregationTypesMapper.getAggregationType(field.getTypeName());
 
-            if (!objectTypeComposer) return res;
+            if (!objectTypeComposer) {
+                return res;
+            }
 
+            if (field.typeHelper.isID()) {
+                return res;
+            }
             res[field.name] = objectTypeComposer.NonNull;
 
             return res;

diff --git a/packages/graphql/src/schema/create-relationship-fields/create-relationship-fields.ts b/packages/graphql/src/schema/create-relationship-fields/create-relationship-fields.ts
@@ -268,7 +268,10 @@ export function createRelationshipFields({
             // make a new fn augmentObjectTypeWithAggregationField
             const fieldAggregationComposer = new FieldAggregationComposer(schemaComposer, subgraph);
 
-            const aggregationTypeObject = fieldAggregationComposer.createAggregationTypeObject(relationshipAdapter);
+            const aggregationTypeObject = fieldAggregationComposer.createAggregationTypeObject(
+                relationshipAdapter,
+                features
+            );
 
             const aggregationFieldsBaseArgs = {
                 where: relationshipTarget.operations.whereInputTypeName,

diff --git a/packages/graphql/src/schema/generation/aggregate-types.ts b/packages/graphql/src/schema/generation/aggregate-types.ts
@@ -45,11 +45,13 @@ export function withAggregateSelectionType({
     aggregationTypesMapper,
     propagatedDirectives,
     composer,
+    features,
 }: {
     entityAdapter: ConcreteEntityAdapter | InterfaceEntityAdapter;
     aggregationTypesMapper: AggregationTypesMapper;
     propagatedDirectives: DirectiveNode[];
     composer: SchemaComposer;
+    features: Neo4jFeaturesSettings | undefined;
 }): ObjectTypeComposer {
     const aggregateSelection = composer.createObjectTC({
         name: entityAdapter.operations.aggregateTypeNames.selection,
@@ -62,23 +64,25 @@ export function withAggregateSelectionType({
         },
         directives: graphqlDirectivesToCompose(propagatedDirectives),
     });
-    aggregateSelection.addFields(makeAggregableFields({ entityAdapter, aggregationTypesMapper }));
+    aggregateSelection.addFields(makeAggregableFields({ entityAdapter, aggregationTypesMapper, features }));
     return aggregateSelection;
 }
 
 function makeAggregableFields({
     entityAdapter,
     aggregationTypesMapper,
+    features,
 }: {
     entityAdapter: ConcreteEntityAdapter | InterfaceEntityAdapter;
     aggregationTypesMapper: AggregationTypesMapper;
+    features: Neo4jFeaturesSettings | undefined;
 }): ObjectTypeComposerFieldConfigMapDefinition<any, any> {
     const aggregableFields: ObjectTypeComposerFieldConfigMapDefinition<any, any> = {};
     const aggregableAttributes = entityAdapter.aggregableFields;
     for (const attribute of aggregableAttributes) {
         const objectTypeComposer = aggregationTypesMapper.getAggregationType(attribute.getTypeName());
         if (objectTypeComposer) {
-            aggregableFields[attribute.name] = objectTypeComposer.NonNull;
+            aggregableFields[attribute.name] = { type: objectTypeComposer.NonNull };
         }
     }
     return aggregableFields;
@@ -214,7 +218,7 @@ function makeAggregationFields(
 function addDeprecatedAggregationFieldsByType(
     attribute: AttributeAdapter,
     directivesOnField: DirectiveNode[] | undefined,
-    fields: InputTypeComposerFieldConfigMapDefinition
+    fields: InputTypeComposerFieldConfigMapDefinition,
 ): InputTypeComposerFieldConfigMapDefinition {
     if (attribute.typeHelper.isString()) {
         for (const operator of AGGREGATION_COMPARISON_OPERATORS) {

diff --git a/packages/graphql/src/schema/make-augmented-schema.ts b/packages/graphql/src/schema/make-augmented-schema.ts
@@ -701,6 +701,7 @@ function generateObjectType({
             aggregationTypesMapper,
             propagatedDirectives,
             composer,
+            features,
         });
 
         composer.Query.addFields({
@@ -845,6 +846,7 @@ function generateInterfaceObjectType({
             aggregationTypesMapper,
             propagatedDirectives,
             composer,
+            features,
         });
 
         composer.Query.addFields({