7.x #5767

darrellwarde · 2024-11-08T13:21:42Z

No description provided.

changeset-bot · 2024-11-08T13:21:47Z

🦋 Changeset detected

Latest commit: 5a4e23f

The changes in this PR will be included in the next version bump.

This PR includes changesets to release 1 package

Name	Type
@neo4j/graphql	Major

Not sure what this means? Click here to learn what changesets are.

Click here if you're a maintainer who wants to add another changeset to this PR

…cated-aggregate

Remove deprecated aggregation fields

* Subscriptions as an opt-in feature * Remove inline await * Update tests

[Feature Branch] Aggregation 7

github-actions · 2025-03-10T15:30:43Z

packages/graphql/tests/integration/filtering/typename-in.int.test.ts

⚠️ [eslint] <jest/no-disabled-tests> _{reported by reviewdog 🐶}
Disabled test

graphql/packages/graphql/tests/integration/filtering/typename-in.int.test.ts

Lines 176 to 204 in e421830

test.skip("nested aggregation", async () => {

const query = `

{

${Actor.plural} {

actedInConnection(where: { NOT: { typename: [${Movie.name}, ${Series.name}] } }) {

aggregate {

count {

nodes

}

}

}

}

}

`;

const queryResult = await testHelper.executeGraphQL(query);

expect(queryResult.errors).toBeUndefined();

expect(queryResult.data).toEqual({

[Actor.plural]: expect.arrayContaining([

{

actedInConnection: {

count: {

nodes: 1,

},

},

},

]),

});

});

github-actions · 2025-03-10T15:30:44Z

packages/graphql/tests/schema/directives/filterable.test.ts

⚠️ [eslint] <jest/no-disabled-tests> _{reported by reviewdog 🐶}
Disabled test

graphql/packages/graphql/tests/schema/directives/filterable.test.ts

Lines 30 to 89 in e421830

test.skip("default arguments should disable aggregation", async () => {

const typeDefs = /* GraphQL */ `

type Actor @node {

username: String!

movies: [Movie!]! @relationship(type: "ACTED_IN", direction: OUT)

}

type Movie @subscription @node {

title: String @filterable

actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN)

}

`;

const neoSchema = new Neo4jGraphQL({

typeDefs,

features: {

subscriptions: new TestCDCEngine(),

excludeDeprecatedFields: {

aggregationFiltersOutsideConnection: true,

},

},

});

const schema = await neoSchema.getSchema();

const movieWhereType = schema.getType("MovieWhere") as GraphQLInputObjectType;

expect(movieWhereType).toBeDefined();

const movieWhereFields = movieWhereType.getFields();

expect(movieWhereFields.title).toBeDefined();

expect(movieWhereFields.releaseDate).toBeDefined();

const movieSubscriptionWhereType = schema.getType("MovieSubscriptionWhere") as GraphQLInputObjectType;

expect(movieSubscriptionWhereType).toBeDefined();

const movieSubscriptionWhereFields = movieSubscriptionWhereType.getFields();

const subscriptionTitle_EQ = movieSubscriptionWhereFields["title_EQ"];

const subscriptionTitle_IN = movieSubscriptionWhereFields["title_IN"];

const subscriptionTitle_CONTAINS = movieSubscriptionWhereFields["title_CONTAINS"];

const subscriptionTitle_STARTS_WITH = movieSubscriptionWhereFields["title_STARTS_WITH"];

const subscriptionTitle_ENDS_WITH = movieSubscriptionWhereFields["title_ENDS_WITH"];

const subscriptionTitleFilters = [

subscriptionTitle_EQ,

subscriptionTitle_IN,

subscriptionTitle_CONTAINS,

subscriptionTitle_STARTS_WITH,

subscriptionTitle_ENDS_WITH,

];

for (const scalarFilter of subscriptionTitleFilters) {

expect(scalarFilter).toBeDefined();

}

const aggregationWhereInput = schema.getType(

"ActorMoviesNodeAggregationWhereInput"

) as GraphQLInputObjectType;

expect(aggregationWhereInput).toBeUndefined();

});

github-actions · 2025-03-10T15:30:47Z

packages/graphql/tests/schema/directives/filterable.test.ts

⚠️ [eslint] <jest/no-disabled-tests> _{reported by reviewdog 🐶}
Disabled test

graphql/packages/graphql/tests/schema/directives/filterable.test.ts

Lines 92 to 163 in e421830

test.skip("enable value and aggregation filters", async () => {

const typeDefs = gql`

type Actor @node {

username: String!

password: String!

movies: [Movie!]! @relationship(type: "ACTED_IN", direction: OUT)

}

type Movie @subscription @node {

title: String @filterable(byValue: true, byAggregate: true)

actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN)

}

`;

const neoSchema = new Neo4jGraphQL({

typeDefs,

features: {

subscriptions: new TestCDCEngine(),

},

});

const schema = await neoSchema.getSchema();

const movieWhereType = schema.getType("MovieWhere") as GraphQLInputObjectType;

expect(movieWhereType).toBeDefined();

const movieWhereFields = movieWhereType.getFields();

const title_EQ = movieWhereFields["title_EQ"];

const title_IN = movieWhereFields["title_IN"];

const title_CONTAINS = movieWhereFields["title_CONTAINS"];

const title_STARTS_WITH = movieWhereFields["title_STARTS_WITH"];

const title_ENDS_WITH = movieWhereFields["title_ENDS_WITH"];

const titleFilters = [title_EQ, title_IN, title_CONTAINS, title_STARTS_WITH, title_ENDS_WITH];

for (const scalarFilter of titleFilters) {

expect(scalarFilter).toBeDefined();

}

const movieSubscriptionWhereType = schema.getType("MovieSubscriptionWhere") as GraphQLInputObjectType;

expect(movieSubscriptionWhereType).toBeDefined();

const movieSubscriptionWhereFields = movieSubscriptionWhereType.getFields();

const subscriptionTitle_EQ = movieSubscriptionWhereFields["title_EQ"];

const subscriptionTitle_IN = movieSubscriptionWhereFields["title_IN"];

const subscriptionTitle_CONTAINS = movieSubscriptionWhereFields["title_CONTAINS"];

const subscriptionTitle_STARTS_WITH = movieSubscriptionWhereFields["title_STARTS_WITH"];

const subscriptionTitle_ENDS_WITH = movieSubscriptionWhereFields["title_ENDS_WITH"];

const subscriptionTitleFilters = [

subscriptionTitle_EQ,

subscriptionTitle_IN,

subscriptionTitle_CONTAINS,

subscriptionTitle_STARTS_WITH,

subscriptionTitle_ENDS_WITH,

];

for (const scalarFilter of subscriptionTitleFilters) {

expect(scalarFilter).toBeDefined();

}

const aggregationWhereInput = schema.getType(

"ActorMoviesNodeAggregationWhereInput"

) as GraphQLInputObjectType;

expect(aggregationWhereInput).toBeDefined();

const aggregationWhereInputFields = aggregationWhereInput.getFields();

const title_AGG = aggregationWhereInputFields["title"];

expect(title_AGG).toBeUndefined();

});

github-actions · 2025-03-10T15:30:48Z

packages/graphql/tests/schema/directives/query.test.ts

⚠️ [eslint] <jest/no-disabled-tests> _{reported by reviewdog 🐶}
Disabled test suite

graphql/packages/graphql/tests/schema/directives/query.test.ts

Lines 25 to 159 in e421830

describe.skip("on OBJECT", () => {

test("default arguments should disable aggregation", async () => {

const typeDefs = /* GraphQL */ `

type Actor @node {

username: String!

password: String!

}

type Movie @query @node {

title: String

}

`;

const neoSchema = new Neo4jGraphQL({ typeDefs });

const schema = await neoSchema.getSchema();

const { movies, actors, moviesConnection, actorsConnection, moviesAggregate, actorsAggregate } = schema

.getQueryType()

?.getFields() as GraphQLFieldMap<any, any>;

expect(movies).toBeDefined();

expect(actors).toBeDefined();

expect(moviesConnection).toBeDefined();

expect(actorsConnection).toBeDefined();

expect(moviesAggregate).toBeUndefined();

expect(actorsAggregate).toBeDefined();

const moviesConnectionType = schema.getType("MoviesConnection") as GraphQLObjectType;

expect(moviesConnectionType).toBeDefined();

const { aggregate, edges } = moviesConnectionType.getFields();

expect(aggregate).toBeUndefined();

expect(edges).toBeDefined();

});

test("should enable aggregation", async () => {

const typeDefs = /* GraphQL */ `

type Actor @node {

username: String!

password: String!

}

type Movie @query(aggregate: true) @node {

title: String

}

`;

const neoSchema = new Neo4jGraphQL({ typeDefs });

const schema = await neoSchema.getSchema();

const { movies, actors, moviesConnection, actorsConnection, moviesAggregate, actorsAggregate } = schema

.getQueryType()

?.getFields() as GraphQLFieldMap<any, any>;

expect(movies).toBeDefined();

expect(actors).toBeDefined();

expect(moviesConnection).toBeDefined();

expect(actorsConnection).toBeDefined();

expect(moviesAggregate).toBeDefined();

expect(actorsAggregate).toBeDefined();

const moviesConnectionType = schema.getType("MoviesConnection") as GraphQLObjectType;

expect(moviesConnectionType).toBeDefined();

const { aggregate, edges } = moviesConnectionType.getFields();

expect(aggregate).toBeDefined();

expect(edges).toBeDefined();

});

test("should disable read and aggregate for Actor", async () => {

const typeDefs = /* GraphQL */ `

type Actor @query(read: false, aggregate: false) @node {

name: String

}

type Movie @node {

title: String

}

`;

const neoSchema = new Neo4jGraphQL({ typeDefs });

const schema = await neoSchema.getSchema();

const { movies, actors, moviesConnection, actorsConnection, moviesAggregate, actorsAggregate } = schema

.getQueryType()

?.getFields() as GraphQLFieldMap<any, any>;

expect(movies).toBeDefined();

expect(actors).toBeUndefined();

expect(moviesConnection).toBeDefined();

expect(actorsConnection).toBeUndefined();

expect(moviesAggregate).toBeDefined();

expect(actorsAggregate).toBeUndefined();

const actorsConnectionType = schema.getType("ActorsConnection") as GraphQLObjectType;

expect(actorsConnectionType).toBeUndefined();

});

test("should disable read and enable aggregate for Actor", async () => {

const typeDefs = /* GraphQL */ `

type Actor @query(read: false, aggregate: true) @node {

name: String

}

type Movie @node {

title: String

}

`;

const neoSchema = new Neo4jGraphQL({ typeDefs });

const schema = await neoSchema.getSchema();

const { movies, actors, moviesConnection, actorsConnection, moviesAggregate, actorsAggregate } = schema

.getQueryType()

?.getFields() as GraphQLFieldMap<any, any>;

expect(movies).toBeDefined();

expect(actors).toBeUndefined();

expect(moviesConnection).toBeDefined();

expect(actorsConnection).toBeDefined();

expect(moviesAggregate).toBeDefined();

expect(actorsAggregate).toBeDefined();

const actorsConnectionType = schema.getType("ActorsConnection") as GraphQLObjectType;

expect(actorsConnectionType).toBeDefined();

const { aggregate, edges } = actorsConnectionType.getFields();

expect(aggregate).toBeDefined();

expect(edges).toBeUndefined();

});

});

github-actions · 2025-03-10T15:30:49Z

packages/graphql/tests/schema/directives/relationship-aggregate.test.ts

⚠️ [eslint] <jest/no-disabled-tests> _{reported by reviewdog 🐶}
Disabled test

graphql/packages/graphql/tests/schema/directives/relationship-aggregate.test.ts

Lines 26 to 53 in e421830

test.skip("the default behavior should enable nested aggregation", async () => {

const typeDefs = /* GraphQL */ `

type Actor @node {

username: String!

password: String!

}

type Movie @node {

title: String

actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN)

}

`;

const neoSchema = new Neo4jGraphQL({ typeDefs });

const schema = await neoSchema.getSchema();

const movieType = schema.getType("Movie") as GraphQLObjectType;

expect(movieType).toBeDefined();

const { actorsAggregate, actorsConnection } = movieType.getFields();

expect(actorsAggregate).toBeDefined();

expect(actorsConnection).toBeDefined();

const { aggregate, edges } = (actorsConnection?.type as GraphQLNonNull<GraphQLObjectType>).ofType.getFields();

expect(aggregate).toBeDefined();

expect(edges).toBeDefined();

});

github-actions · 2025-03-10T15:30:50Z

packages/graphql/tests/schema/directives/relationship-aggregate.test.ts

⚠️ [eslint] <jest/no-disabled-tests> _{reported by reviewdog 🐶}
Disabled test

graphql/packages/graphql/tests/schema/directives/relationship-aggregate.test.ts

Lines 55 to 81 in e421830

test.skip("should disable nested aggregation", async () => {

const typeDefs = /* GraphQL */ `

type Actor @node {

username: String!

password: String!

}

type Movie @node {

title: String

actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN, aggregate: false)

}

`;

const neoSchema = new Neo4jGraphQL({ typeDefs });

const schema = await neoSchema.getSchema();

const movieType = schema.getType("Movie") as GraphQLObjectType;

expect(movieType).toBeDefined();

const { actorsAggregate, actorsConnection } = movieType.getFields();

expect(actorsAggregate).toBeUndefined();

expect(actorsConnection).toBeDefined();

const { aggregate, edges } = (actorsConnection?.type as GraphQLNonNull<GraphQLObjectType>).ofType.getFields();

expect(aggregate).toBeUndefined();

expect(edges).toBeDefined();

});

github-actions · 2025-03-10T15:30:51Z

packages/graphql/tests/schema/directives/relationship-aggregate.test.ts

⚠️ [eslint] <jest/no-disabled-tests> _{reported by reviewdog 🐶}
Disabled test

graphql/packages/graphql/tests/schema/directives/relationship-aggregate.test.ts

Lines 83 to 109 in e421830

test.skip("should enable nested aggregation", async () => {

const typeDefs = /* GraphQL */ `

type Actor @node {

username: String!

password: String!

}

type Movie @node {

title: String

actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN, aggregate: true)

}

`;

const neoSchema = new Neo4jGraphQL({ typeDefs });

const schema = await neoSchema.getSchema();

const movieType = schema.getType("Movie") as GraphQLObjectType;

expect(movieType).toBeDefined();

const { actorsAggregate, actorsConnection } = movieType.getFields();

expect(actorsAggregate).toBeDefined();

expect(actorsConnection).toBeDefined();

const { aggregate, edges } = (actorsConnection?.type as GraphQLNonNull<GraphQLObjectType>).ofType.getFields();

expect(aggregate).toBeDefined();

expect(edges).toBeDefined();

});

github-actions · 2025-03-10T15:30:53Z

packages/graphql/tests/schema/directives/relationship-aggregate.test.ts

⚠️ [eslint] <jest/no-disabled-tests> _{reported by reviewdog 🐶}
Disabled test

graphql/packages/graphql/tests/schema/directives/relationship-aggregate.test.ts

Lines 111 to 153 in e421830

test.skip("should work in conjunction with @query aggregate:false and @relationship aggregate:true", async () => {

const typeDefs = /* GraphQL */ `

type Actor @query(aggregate: false) @node {

username: String!

password: String!

}

type Movie @node {

title: String

actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN, aggregate: true)

}

`;

const neoSchema = new Neo4jGraphQL({ typeDefs });

const schema = await neoSchema.getSchema();

const movieType = schema.getType("Movie") as GraphQLObjectType;

expect(movieType).toBeDefined();

const { actorsAggregate, actorsConnection } = movieType.getFields();

expect(actorsAggregate).toBeDefined();

expect(actorsConnection).toBeDefined();

const { aggregate, edges } = (actorsConnection?.type as GraphQLNonNull<GraphQLObjectType>).ofType.getFields();

expect(aggregate).toBeDefined();

expect(edges).toBeDefined();

const { actorsAggregate: topLevelActorsAggregate, actorsConnection: topLevelActorsConnection } = schema

.getQueryType()

?.getFields() as GraphQLFieldMap<any, any>;

expect(topLevelActorsAggregate).toBeUndefined();

expect(topLevelActorsConnection).toBeDefined();

const { aggregate: topLevelAggregateInsideConnection, edges: topLevelEdgesInsideConnection } = (

topLevelActorsConnection?.type as GraphQLNonNull<GraphQLObjectType>

).ofType.getFields();

expect(topLevelAggregateInsideConnection).toBeUndefined();

expect(topLevelEdgesInsideConnection).toBeDefined();

});

github-actions · 2025-03-10T15:30:54Z

packages/graphql/tests/schema/directives/relationship-aggregate.test.ts

⚠️ [eslint] <jest/no-disabled-tests> _{reported by reviewdog 🐶}
Disabled test

graphql/packages/graphql/tests/schema/directives/relationship-aggregate.test.ts

Lines 155 to 196 in e421830

test.skip("should work in conjunction with @query aggregate:true and @relationship aggregate:false", async () => {

const typeDefs = /* GraphQL */ `

type Actor @query(aggregate: true) @node {

username: String!

password: String!

}

type Movie @node {

title: String

actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN, aggregate: false)

}

`;

const neoSchema = new Neo4jGraphQL({ typeDefs });

const schema = await neoSchema.getSchema();

const movieType = schema.getType("Movie") as GraphQLObjectType;

expect(movieType).toBeDefined();

const { actorsAggregate, actorsConnection } = movieType.getFields();

expect(actorsAggregate).toBeUndefined();

expect(actorsConnection).toBeDefined();

const { aggregate, edges } = (actorsConnection?.type as GraphQLNonNull<GraphQLObjectType>).ofType.getFields();

expect(aggregate).toBeUndefined();

expect(edges).toBeDefined();

const { actorsAggregate: topLevelActorsAggregate, actorsConnection: topLevelActorsConnection } = schema

.getQueryType()

?.getFields() as GraphQLFieldMap<any, any>;

expect(topLevelActorsAggregate).toBeDefined();

expect(topLevelActorsConnection).toBeDefined();

const { aggregate: topLevelAggregateInsideConnection, edges: topLevelEdgesInsideConnection } = (

topLevelActorsConnection?.type as GraphQLNonNull<GraphQLObjectType>

).ofType.getFields();

expect(topLevelAggregateInsideConnection).toBeDefined();

expect(topLevelEdgesInsideConnection).toBeDefined();

});

neo4j-team-graphql added the graphql label Nov 8, 2024

darrellwarde temporarily deployed to npm November 8, 2024 13:22 — with GitHub Actions Inactive

angrykoala temporarily deployed to npm November 8, 2024 15:58 — with GitHub Actions Inactive

neo4j-team-graphql removed the graphql label Nov 8, 2024

angrykoala temporarily deployed to npm November 8, 2024 16:14 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm November 8, 2024 16:56 — with GitHub Actions Inactive

MacondoExpress temporarily deployed to npm November 12, 2024 16:03 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm November 13, 2024 16:44 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm November 13, 2024 16:57 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm November 13, 2024 17:08 — with GitHub Actions Inactive

angrykoala temporarily deployed to npm November 14, 2024 12:08 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm November 14, 2024 16:15 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm November 18, 2024 11:12 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm November 18, 2024 15:37 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm November 18, 2024 15:41 — with GitHub Actions Inactive

angrykoala temporarily deployed to npm November 19, 2024 15:37 — with GitHub Actions Inactive

angrykoala temporarily deployed to npm November 20, 2024 17:22 — with GitHub Actions Inactive

MacondoExpress temporarily deployed to npm November 21, 2024 10:37 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm November 21, 2024 14:38 — with GitHub Actions Inactive

MacondoExpress temporarily deployed to npm November 25, 2024 13:03 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm November 26, 2024 12:06 — with GitHub Actions Inactive

angrykoala temporarily deployed to npm November 27, 2024 17:28 — with GitHub Actions Inactive

mjfwebb temporarily deployed to npm November 29, 2024 15:35 — with GitHub Actions Inactive

mjfwebb temporarily deployed to npm November 29, 2024 15:38 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm December 3, 2024 14:54 — with GitHub Actions Inactive

darrellwarde temporarily deployed to npm December 4, 2024 09:32 — with GitHub Actions Inactive

angrykoala temporarily deployed to npm December 6, 2024 15:25 — with GitHub Actions Inactive

angrykoala temporarily deployed to npm December 9, 2024 09:29 — with GitHub Actions Inactive

a-alle temporarily deployed to npm December 9, 2024 12:43 — with GitHub Actions Inactive

angrykoala added 3 commits March 3, 2025 17:21

Merge remote-tracking branch 'origin/aggregation-7' into remove-depre…

fee3aaf

…cated-aggregate

Merge pull request #6027 from neo4j/remove-deprecated-aggregate

6a519cd

Remove deprecated aggregation fields

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

0cf27ac

angrykoala temporarily deployed to npm March 7, 2025 16:14 — with GitHub Actions Inactive

Subscriptions as an opt-in feature (#6048)

c667618

* Subscriptions as an opt-in feature * Remove inline await * Update tests

darrellwarde temporarily deployed to npm March 10, 2025 12:36 — with GitHub Actions Inactive

angrykoala added 3 commits March 10, 2025 14:40

Merge remote-tracking branch 'origin/7.x' into aggregation-7

8ef943e

update yarn lock file

4329878

Merge pull request #6011 from neo4j/aggregation-7

68a0bc4

[Feature Branch] Aggregation 7

angrykoala temporarily deployed to npm March 10, 2025 14:50 — with GitHub Actions Inactive

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

e421830

angrykoala temporarily deployed to npm March 10, 2025 15:29 — with GitHub Actions Inactive

github-actions bot reviewed Mar 10, 2025

View reviewed changes

Remove old skipped tests

c5db901

angrykoala temporarily deployed to npm March 11, 2025 10:00 — with GitHub Actions Inactive

Update CODEOWNERS (#6074)

5a4e23f

mjfwebb requested review from angrykoala, mjfwebb, MacondoExpress, a-alle and Liam-Doodson as code owners March 12, 2025 15:24

mjfwebb temporarily deployed to npm March 12, 2025 15:24 — with GitHub Actions Inactive

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

7.x #5767

7.x #5767

darrellwarde commented Nov 8, 2024

changeset-bot bot commented Nov 8, 2024 •

edited

Loading

github-actions bot Mar 10, 2025

github-actions bot Mar 10, 2025

github-actions bot Mar 10, 2025

github-actions bot Mar 10, 2025

github-actions bot Mar 10, 2025

github-actions bot Mar 10, 2025

github-actions bot Mar 10, 2025

github-actions bot Mar 10, 2025

github-actions bot Mar 10, 2025

	test.skip("nested aggregation", async () => {
	const query = `
	{
	${Actor.plural} {
	actedInConnection(where: { NOT: { typename: [${Movie.name}, ${Series.name}] } }) {
	aggregate {
	count {
	nodes
	}
	}
	}
	}
	}
	`;

	const queryResult = await testHelper.executeGraphQL(query);
	expect(queryResult.errors).toBeUndefined();
	expect(queryResult.data).toEqual({
	[Actor.plural]: expect.arrayContaining([
	{
	actedInConnection: {
	count: {
	nodes: 1,
	},
	},
	},
	]),
	});
	});

	test.skip("default arguments should disable aggregation", async () => {
	const typeDefs = /* GraphQL */ `
	type Actor @node {
	username: String!
	movies: [Movie!]! @relationship(type: "ACTED_IN", direction: OUT)
	}

	type Movie @subscription @node {
	title: String @filterable
	actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN)
	}
	`;
	const neoSchema = new Neo4jGraphQL({
	typeDefs,
	features: {
	subscriptions: new TestCDCEngine(),
	excludeDeprecatedFields: {
	aggregationFiltersOutsideConnection: true,
	},
	},
	});
	const schema = await neoSchema.getSchema();
	const movieWhereType = schema.getType("MovieWhere") as GraphQLInputObjectType;

	expect(movieWhereType).toBeDefined();

	const movieWhereFields = movieWhereType.getFields();
	expect(movieWhereFields.title).toBeDefined();
	expect(movieWhereFields.releaseDate).toBeDefined();

	const movieSubscriptionWhereType = schema.getType("MovieSubscriptionWhere") as GraphQLInputObjectType;

	expect(movieSubscriptionWhereType).toBeDefined();

	const movieSubscriptionWhereFields = movieSubscriptionWhereType.getFields();

	const subscriptionTitle_EQ = movieSubscriptionWhereFields["title_EQ"];
	const subscriptionTitle_IN = movieSubscriptionWhereFields["title_IN"];
	const subscriptionTitle_CONTAINS = movieSubscriptionWhereFields["title_CONTAINS"];
	const subscriptionTitle_STARTS_WITH = movieSubscriptionWhereFields["title_STARTS_WITH"];
	const subscriptionTitle_ENDS_WITH = movieSubscriptionWhereFields["title_ENDS_WITH"];

	const subscriptionTitleFilters = [
	subscriptionTitle_EQ,
	subscriptionTitle_IN,
	subscriptionTitle_CONTAINS,
	subscriptionTitle_STARTS_WITH,
	subscriptionTitle_ENDS_WITH,
	];

	for (const scalarFilter of subscriptionTitleFilters) {
	expect(scalarFilter).toBeDefined();
	}

	const aggregationWhereInput = schema.getType(
	"ActorMoviesNodeAggregationWhereInput"
	) as GraphQLInputObjectType;

	expect(aggregationWhereInput).toBeUndefined();
	});

	test.skip("enable value and aggregation filters", async () => {
	const typeDefs = gql`
	type Actor @node {
	username: String!
	password: String!
	movies: [Movie!]! @relationship(type: "ACTED_IN", direction: OUT)
	}

	type Movie @subscription @node {
	title: String @filterable(byValue: true, byAggregate: true)
	actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN)
	}
	`;
	const neoSchema = new Neo4jGraphQL({
	typeDefs,
	features: {
	subscriptions: new TestCDCEngine(),
	},
	});
	const schema = await neoSchema.getSchema();

	const movieWhereType = schema.getType("MovieWhere") as GraphQLInputObjectType;
	expect(movieWhereType).toBeDefined();

	const movieWhereFields = movieWhereType.getFields();
	const title_EQ = movieWhereFields["title_EQ"];
	const title_IN = movieWhereFields["title_IN"];
	const title_CONTAINS = movieWhereFields["title_CONTAINS"];
	const title_STARTS_WITH = movieWhereFields["title_STARTS_WITH"];
	const title_ENDS_WITH = movieWhereFields["title_ENDS_WITH"];

	const titleFilters = [title_EQ, title_IN, title_CONTAINS, title_STARTS_WITH, title_ENDS_WITH];

	for (const scalarFilter of titleFilters) {
	expect(scalarFilter).toBeDefined();
	}

	const movieSubscriptionWhereType = schema.getType("MovieSubscriptionWhere") as GraphQLInputObjectType;

	expect(movieSubscriptionWhereType).toBeDefined();

	const movieSubscriptionWhereFields = movieSubscriptionWhereType.getFields();

	const subscriptionTitle_EQ = movieSubscriptionWhereFields["title_EQ"];
	const subscriptionTitle_IN = movieSubscriptionWhereFields["title_IN"];
	const subscriptionTitle_CONTAINS = movieSubscriptionWhereFields["title_CONTAINS"];
	const subscriptionTitle_STARTS_WITH = movieSubscriptionWhereFields["title_STARTS_WITH"];
	const subscriptionTitle_ENDS_WITH = movieSubscriptionWhereFields["title_ENDS_WITH"];

	const subscriptionTitleFilters = [
	subscriptionTitle_EQ,
	subscriptionTitle_IN,
	subscriptionTitle_CONTAINS,
	subscriptionTitle_STARTS_WITH,
	subscriptionTitle_ENDS_WITH,
	];

	for (const scalarFilter of subscriptionTitleFilters) {
	expect(scalarFilter).toBeDefined();
	}

	const aggregationWhereInput = schema.getType(
	"ActorMoviesNodeAggregationWhereInput"
	) as GraphQLInputObjectType;

	expect(aggregationWhereInput).toBeDefined();
	const aggregationWhereInputFields = aggregationWhereInput.getFields();

	const title_AGG = aggregationWhereInputFields["title"];

	expect(title_AGG).toBeUndefined();
	});

	describe.skip("on OBJECT", () => {
	test("default arguments should disable aggregation", async () => {
	const typeDefs = /* GraphQL */ `
	type Actor @node {
	username: String!
	password: String!
	}

	type Movie @query @node {
	title: String
	}
	`;

	const neoSchema = new Neo4jGraphQL({ typeDefs });
	const schema = await neoSchema.getSchema();
	const { movies, actors, moviesConnection, actorsConnection, moviesAggregate, actorsAggregate } = schema
	.getQueryType()
	?.getFields() as GraphQLFieldMap<any, any>;

	expect(movies).toBeDefined();
	expect(actors).toBeDefined();

	expect(moviesConnection).toBeDefined();
	expect(actorsConnection).toBeDefined();

	expect(moviesAggregate).toBeUndefined();
	expect(actorsAggregate).toBeDefined();

	const moviesConnectionType = schema.getType("MoviesConnection") as GraphQLObjectType;
	expect(moviesConnectionType).toBeDefined();
	const { aggregate, edges } = moviesConnectionType.getFields();

	expect(aggregate).toBeUndefined();
	expect(edges).toBeDefined();
	});

	test("should enable aggregation", async () => {
	const typeDefs = /* GraphQL */ `
	type Actor @node {
	username: String!
	password: String!
	}

	type Movie @query(aggregate: true) @node {
	title: String
	}
	`;

	const neoSchema = new Neo4jGraphQL({ typeDefs });
	const schema = await neoSchema.getSchema();
	const { movies, actors, moviesConnection, actorsConnection, moviesAggregate, actorsAggregate } = schema
	.getQueryType()
	?.getFields() as GraphQLFieldMap<any, any>;

	expect(movies).toBeDefined();
	expect(actors).toBeDefined();

	expect(moviesConnection).toBeDefined();
	expect(actorsConnection).toBeDefined();

	expect(moviesAggregate).toBeDefined();
	expect(actorsAggregate).toBeDefined();

	const moviesConnectionType = schema.getType("MoviesConnection") as GraphQLObjectType;
	expect(moviesConnectionType).toBeDefined();
	const { aggregate, edges } = moviesConnectionType.getFields();

	expect(aggregate).toBeDefined();
	expect(edges).toBeDefined();
	});

	test("should disable read and aggregate for Actor", async () => {
	const typeDefs = /* GraphQL */ `
	type Actor @query(read: false, aggregate: false) @node {
	name: String
	}

	type Movie @node {
	title: String
	}
	`;
	const neoSchema = new Neo4jGraphQL({ typeDefs });

	const schema = await neoSchema.getSchema();
	const { movies, actors, moviesConnection, actorsConnection, moviesAggregate, actorsAggregate } = schema
	.getQueryType()
	?.getFields() as GraphQLFieldMap<any, any>;

	expect(movies).toBeDefined();
	expect(actors).toBeUndefined();

	expect(moviesConnection).toBeDefined();
	expect(actorsConnection).toBeUndefined();

	expect(moviesAggregate).toBeDefined();
	expect(actorsAggregate).toBeUndefined();

	const actorsConnectionType = schema.getType("ActorsConnection") as GraphQLObjectType;
	expect(actorsConnectionType).toBeUndefined();
	});

	test("should disable read and enable aggregate for Actor", async () => {
	const typeDefs = /* GraphQL */ `
	type Actor @query(read: false, aggregate: true) @node {
	name: String
	}

	type Movie @node {
	title: String
	}
	`;
	const neoSchema = new Neo4jGraphQL({ typeDefs });

	const schema = await neoSchema.getSchema();
	const { movies, actors, moviesConnection, actorsConnection, moviesAggregate, actorsAggregate } = schema
	.getQueryType()
	?.getFields() as GraphQLFieldMap<any, any>;

	expect(movies).toBeDefined();
	expect(actors).toBeUndefined();

	expect(moviesConnection).toBeDefined();
	expect(actorsConnection).toBeDefined();

	expect(moviesAggregate).toBeDefined();
	expect(actorsAggregate).toBeDefined();

	const actorsConnectionType = schema.getType("ActorsConnection") as GraphQLObjectType;
	expect(actorsConnectionType).toBeDefined();
	const { aggregate, edges } = actorsConnectionType.getFields();

	expect(aggregate).toBeDefined();
	expect(edges).toBeUndefined();
	});
	});

	test.skip("the default behavior should enable nested aggregation", async () => {
	const typeDefs = /* GraphQL */ `
	type Actor @node {
	username: String!
	password: String!
	}

	type Movie @node {
	title: String
	actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN)
	}
	`;

	const neoSchema = new Neo4jGraphQL({ typeDefs });
	const schema = await neoSchema.getSchema();

	const movieType = schema.getType("Movie") as GraphQLObjectType;
	expect(movieType).toBeDefined();

	const { actorsAggregate, actorsConnection } = movieType.getFields();

	expect(actorsAggregate).toBeDefined();
	expect(actorsConnection).toBeDefined();

	const { aggregate, edges } = (actorsConnection?.type as GraphQLNonNull<GraphQLObjectType>).ofType.getFields();
	expect(aggregate).toBeDefined();
	expect(edges).toBeDefined();
	});

	test.skip("should disable nested aggregation", async () => {
	const typeDefs = /* GraphQL */ `
	type Actor @node {
	username: String!
	password: String!
	}

	type Movie @node {
	title: String
	actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN, aggregate: false)
	}
	`;

	const neoSchema = new Neo4jGraphQL({ typeDefs });
	const schema = await neoSchema.getSchema();
	const movieType = schema.getType("Movie") as GraphQLObjectType;
	expect(movieType).toBeDefined();

	const { actorsAggregate, actorsConnection } = movieType.getFields();

	expect(actorsAggregate).toBeUndefined();
	expect(actorsConnection).toBeDefined();

	const { aggregate, edges } = (actorsConnection?.type as GraphQLNonNull<GraphQLObjectType>).ofType.getFields();
	expect(aggregate).toBeUndefined();
	expect(edges).toBeDefined();
	});

	test.skip("should enable nested aggregation", async () => {
	const typeDefs = /* GraphQL */ `
	type Actor @node {
	username: String!
	password: String!
	}

	type Movie @node {
	title: String
	actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN, aggregate: true)
	}
	`;

	const neoSchema = new Neo4jGraphQL({ typeDefs });
	const schema = await neoSchema.getSchema();
	const movieType = schema.getType("Movie") as GraphQLObjectType;
	expect(movieType).toBeDefined();

	const { actorsAggregate, actorsConnection } = movieType.getFields();

	expect(actorsAggregate).toBeDefined();
	expect(actorsConnection).toBeDefined();

	const { aggregate, edges } = (actorsConnection?.type as GraphQLNonNull<GraphQLObjectType>).ofType.getFields();
	expect(aggregate).toBeDefined();
	expect(edges).toBeDefined();
	});

	test.skip("should work in conjunction with @query aggregate:false and @relationship aggregate:true", async () => {
	const typeDefs = /* GraphQL */ `
	type Actor @query(aggregate: false) @node {
	username: String!
	password: String!
	}

	type Movie @node {
	title: String
	actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN, aggregate: true)
	}
	`;

	const neoSchema = new Neo4jGraphQL({ typeDefs });

	const schema = await neoSchema.getSchema();
	const movieType = schema.getType("Movie") as GraphQLObjectType;
	expect(movieType).toBeDefined();

	const { actorsAggregate, actorsConnection } = movieType.getFields();

	expect(actorsAggregate).toBeDefined();
	expect(actorsConnection).toBeDefined();

	const { aggregate, edges } = (actorsConnection?.type as GraphQLNonNull<GraphQLObjectType>).ofType.getFields();

	expect(aggregate).toBeDefined();
	expect(edges).toBeDefined();

	const { actorsAggregate: topLevelActorsAggregate, actorsConnection: topLevelActorsConnection } = schema
	.getQueryType()
	?.getFields() as GraphQLFieldMap<any, any>;

	expect(topLevelActorsAggregate).toBeUndefined();
	expect(topLevelActorsConnection).toBeDefined();

	const { aggregate: topLevelAggregateInsideConnection, edges: topLevelEdgesInsideConnection } = (
	topLevelActorsConnection?.type as GraphQLNonNull<GraphQLObjectType>
	).ofType.getFields();

	expect(topLevelAggregateInsideConnection).toBeUndefined();
	expect(topLevelEdgesInsideConnection).toBeDefined();
	});

	test.skip("should work in conjunction with @query aggregate:true and @relationship aggregate:false", async () => {
	const typeDefs = /* GraphQL */ `
	type Actor @query(aggregate: true) @node {
	username: String!
	password: String!
	}

	type Movie @node {
	title: String
	actors: [Actor!]! @relationship(type: "ACTED_IN", direction: IN, aggregate: false)
	}
	`;

	const neoSchema = new Neo4jGraphQL({ typeDefs });
	const schema = await neoSchema.getSchema();
	const movieType = schema.getType("Movie") as GraphQLObjectType;
	expect(movieType).toBeDefined();

	const { actorsAggregate, actorsConnection } = movieType.getFields();

	expect(actorsAggregate).toBeUndefined();
	expect(actorsConnection).toBeDefined();

	const { aggregate, edges } = (actorsConnection?.type as GraphQLNonNull<GraphQLObjectType>).ofType.getFields();

	expect(aggregate).toBeUndefined();
	expect(edges).toBeDefined();

	const { actorsAggregate: topLevelActorsAggregate, actorsConnection: topLevelActorsConnection } = schema
	.getQueryType()
	?.getFields() as GraphQLFieldMap<any, any>;

	expect(topLevelActorsAggregate).toBeDefined();
	expect(topLevelActorsConnection).toBeDefined();

	const { aggregate: topLevelAggregateInsideConnection, edges: topLevelEdgesInsideConnection } = (
	topLevelActorsConnection?.type as GraphQLNonNull<GraphQLObjectType>
	).ofType.getFields();

	expect(topLevelAggregateInsideConnection).toBeDefined();
	expect(topLevelEdgesInsideConnection).toBeDefined();
	});

7.x #5767

Are you sure you want to change the base?

7.x #5767

Conversation

darrellwarde commented Nov 8, 2024

changeset-bot bot commented Nov 8, 2024 • edited Loading

🦋 Changeset detected

github-actions bot Mar 10, 2025

Choose a reason for hiding this comment

github-actions bot Mar 10, 2025

Choose a reason for hiding this comment

github-actions bot Mar 10, 2025

Choose a reason for hiding this comment

github-actions bot Mar 10, 2025

Choose a reason for hiding this comment

github-actions bot Mar 10, 2025

Choose a reason for hiding this comment

github-actions bot Mar 10, 2025

Choose a reason for hiding this comment

github-actions bot Mar 10, 2025

Choose a reason for hiding this comment

github-actions bot Mar 10, 2025

Choose a reason for hiding this comment

github-actions bot Mar 10, 2025

Choose a reason for hiding this comment

changeset-bot bot commented Nov 8, 2024 •

edited

Loading