From a013f22c2eaa578950a1e9dd1d674fc11a29b2b2 Mon Sep 17 00:00:00 2001 From: Mora Date: Tue, 14 May 2024 14:36:44 -0700 Subject: [PATCH 01/29] adding mock blog posts to seed data --- dockerfiles/db/setup.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dockerfiles/db/setup.sql b/dockerfiles/db/setup.sql index 7c72429e..dfb17e62 100644 --- a/dockerfiles/db/setup.sql +++ b/dockerfiles/db/setup.sql @@ -50,7 +50,7 @@ create table blog( ); -create type blog_post_status as enum ('PENDING', 'RELEASED'); +create type blog_post_status as enum ('PENDING', 'RELEASED', 'ARCHIVED'); create table blog_post( From 793254a1d57547177bfc216b75a5262bc813a20a Mon Sep 17 00:00:00 2001 From: Mora Date: Tue, 14 May 2024 14:52:02 -0700 Subject: [PATCH 02/29] adding list type to filterable types --- src/graphql.rs | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/src/graphql.rs b/src/graphql.rs index cb8c92e8..78d91157 100644 --- a/src/graphql.rs +++ b/src/graphql.rs @@ -1116,6 +1116,7 @@ pub struct OrderByEntityType { pub enum FilterableType { Scalar(Scalar), Enum(EnumType), + List(ListType), } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1129,6 +1130,7 @@ impl FilterTypeType { match &self.entity { FilterableType::Scalar(s) => s.name().expect("scalar name should exist"), FilterableType::Enum(e) => e.name().expect("enum type name should exist"), + FilterableType::List(l) => l.name().expect("list type name should exist"), } } } @@ -3620,14 +3622,11 @@ impl ___Type for FilterEntityType { .columns .iter() .filter(|x| x.permissions.is_selectable) - // No filtering on arrays - .filter(|x| !x.type_name.ends_with("[]")) // No filtering on composites .filter(|x| !self.schema.context.is_composite(x.type_oid)) // No filtering on json/b. they do not support = or <> .filter(|x| !["json", "jsonb"].contains(&x.type_name.as_ref())) .filter_map(|col| { - // Should be a scalar if let Some(utype) = sql_column_to_graphql_type(col, &self.schema) { let column_graphql_name = self.schema.graphql_column_field_name(col); @@ -3652,11 +3651,20 @@ impl ___Type for FilterEntityType { default_value: None, sql_type: Some(NodeSQLType::Column(Arc::clone(col))), }), - // ERROR HERE - __Type::Enum(s) => Some(__InputValue { + __Type::Enum(e) => Some(__InputValue { + name_: column_graphql_name, + type_: __Type::FilterType(FilterTypeType { + entity: FilterableType::Enum(e), + schema: Arc::clone(&self.schema), + }), + description: None, + default_value: None, + sql_type: Some(NodeSQLType::Column(Arc::clone(col))), + }), + __Type::List(l) => Some(__InputValue { name_: column_graphql_name, type_: __Type::FilterType(FilterTypeType { - entity: FilterableType::Enum(s), + entity: FilterableType::List(l), schema: Arc::clone(&self.schema), }), description: None, From 4f085949465e7d405c16ac8576101e407a9643cc Mon Sep 17 00:00:00 2001 From: Mora Date: Tue, 14 May 2024 16:02:18 -0700 Subject: [PATCH 03/29] adding array filterops --- src/graphql.rs | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/src/graphql.rs b/src/graphql.rs index 78d91157..7d617eef 100644 --- a/src/graphql.rs +++ b/src/graphql.rs @@ -3330,6 +3330,9 @@ pub enum FilterOp { ILike, RegEx, IRegEx, + Contains, + ContainedBy, + Overlap, } impl ToString for FilterOp { @@ -3348,6 +3351,9 @@ impl ToString for FilterOp { Self::ILike => "ilike", Self::RegEx => "regex", Self::IRegEx => "iregex", + Self::Contains => "cs", + Self::ContainedBy => "cd", + Self::Overlap => "ov", } .to_string() } @@ -3371,6 +3377,9 @@ impl FromStr for FilterOp { "ilike" => Ok(Self::ILike), "regex" => Ok(Self::RegEx), "iregex" => Ok(Self::IRegEx), + "cs" => Ok(Self::Contains), + "cd" => Ok(Self::ContainedBy), + "ov" => Ok(Self::Overlap), _ => Err("Invalid filter operation".to_string()), } } @@ -3543,6 +3552,8 @@ impl ___Type for FilterTypeType { default_value: None, sql_type: None, }, + // shouldn't happen since we've covered all cases in supported_ops + _ => panic!("encountered unknown FilterOp") }) .collect() } @@ -3585,6 +3596,36 @@ impl ___Type for FilterTypeType { }, ] } + FilterableType::List(list_type) => { + let supported_ops = vec![ + FilterOp::Contains, + FilterOp::ContainedBy, + FilterOp::Equal, + FilterOp::GreaterThan, + FilterOp::GreaterThanEqualTo, + FilterOp::LessThan, + FilterOp::LessThanEqualTo, + FilterOp::NotEqual, + FilterOp::Overlap, + ]; + + supported_ops + .iter() + .map(|op| match op { + _ => __InputValue { + name_: op.to_string(), + type_: __Type::List(ListType { + type_: Box::new(__Type::NonNull(NonNullType { + type_: Box::new(*list_type.type_.clone()), + })), + }), + description: None, + default_value: None, + sql_type: None, + }, + }) + .collect() + } }; infields.sort_by_key(|a| a.name()); From fb61169679e1af8931892b18064a5141c5c10a21 Mon Sep 17 00:00:00 2001 From: Mora Date: Tue, 14 May 2024 19:46:16 -0700 Subject: [PATCH 04/29] using modified type for match --- src/graphql.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/graphql.rs b/src/graphql.rs index 7d617eef..9a63d6dd 100644 --- a/src/graphql.rs +++ b/src/graphql.rs @@ -3681,7 +3681,7 @@ impl ___Type for FilterEntityType { not_column_exists = true; } - match utype.unmodified_type() { + match utype { __Type::Scalar(s) => Some(__InputValue { name_: column_graphql_name, type_: __Type::FilterType(FilterTypeType { From 163707e23de2077d1b82a70968f7530141021309 Mon Sep 17 00:00:00 2001 From: Mora Date: Tue, 14 May 2024 19:47:16 -0700 Subject: [PATCH 05/29] adding array filter types to transpiler --- src/transpile.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/transpile.rs b/src/transpile.rs index fc9bcc24..3df92baf 100644 --- a/src/transpile.rs +++ b/src/transpile.rs @@ -714,6 +714,9 @@ impl FilterBuilderElem { _ => { let cast_type_name = match op { FilterOp::In => format!("{}[]", column.type_name), + FilterOp::Contains => format!("{}[]", column.type_name), + FilterOp::ContainedBy => format!("{}[]", column.type_name), + FilterOp::Overlap => format!("{}[]", column.type_name), _ => column.type_name.clone(), }; @@ -735,6 +738,9 @@ impl FilterBuilderElem { FilterOp::ILike => "ilike", FilterOp::RegEx => "~", FilterOp::IRegEx => "~*", + FilterOp::Contains => "@>", + FilterOp::ContainedBy => "<@", + FilterOp::Overlap => "&&", FilterOp::Is => { return Err("Error transpiling Is filter".to_string()); } From 91b6b170465b8ef0986814bf6451f105ca4c49c0 Mon Sep 17 00:00:00 2001 From: Mora Date: Tue, 14 May 2024 23:40:09 -0700 Subject: [PATCH 06/29] adding array filtering to builder --- src/builder.rs | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) diff --git a/src/builder.rs b/src/builder.rs index 4ed5df54..847974cb 100644 --- a/src/builder.rs +++ b/src/builder.rs @@ -1137,7 +1137,7 @@ fn create_filters( } } } - gson::Value::Array(values) if k == AND_FILTER_NAME || k == OR_FILTER_NAME => { + gson::Value::Array(values) => if k == AND_FILTER_NAME || k == OR_FILTER_NAME { // If there are no inner filters we avoid creating an argumentless `and`/`or` expression // which would have been anyways compiled away during transpilation if !values.is_empty() { @@ -1171,8 +1171,30 @@ fn create_filters( filters.push(filter_builder); } + } else { + if !values.is_empty() { + for value in values { + match value { + gson::Value::Object(filter_op_to_value_map) => { + for (filter_op_str, filter_val) in filter_op_to_value_map { + let filter_op = FilterOp::from_str(filter_op_str)?; + + // Skip absent + // Technically nulls should be treated as literals. It will always filter out all rows + // val null is never true + if filter_val == &gson::Value::Absent { + continue; + } + + filters.push(create_filter_builder_elem(filter_iv, filter_op, filter_val)?); + } + }, + _ => return Err("Filter re-validation error op_to_value map".to_string()), + } + } + } } - _ => return Err("Filter re-validation errror op_to_value map".to_string()), + _ => return Err("Filter re-validation error op_to_value map".to_string()), } } Ok(filters) From c425f8f14cadd84ffe33f4f1d120f7bb9192753a Mon Sep 17 00:00:00 2001 From: Mora Date: Tue, 14 May 2024 23:55:07 -0700 Subject: [PATCH 07/29] fixing array filter input fields --- src/graphql.rs | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/graphql.rs b/src/graphql.rs index 9a63d6dd..cd3b3e5e 100644 --- a/src/graphql.rs +++ b/src/graphql.rs @@ -3704,9 +3704,13 @@ impl ___Type for FilterEntityType { }), __Type::List(l) => Some(__InputValue { name_: column_graphql_name, - type_: __Type::FilterType(FilterTypeType { - entity: FilterableType::List(l), - schema: Arc::clone(&self.schema), + type_: __Type::List(ListType { + type_: Box::new(__Type::NonNull(NonNullType { + type_: Box::new(__Type::FilterType(FilterTypeType { + entity: FilterableType::List(l), + schema: Arc::clone(&self.schema), + })), + })), }), description: None, default_value: None, From 237a0a8306b55e462be05cd6c4e6fcb8db4b34d4 Mon Sep 17 00:00:00 2001 From: Mora Date: Tue, 14 May 2024 23:55:36 -0700 Subject: [PATCH 08/29] adding list filter types to schema --- src/graphql.rs | 66 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/src/graphql.rs b/src/graphql.rs index cd3b3e5e..f9a814b8 100644 --- a/src/graphql.rs +++ b/src/graphql.rs @@ -4021,6 +4021,72 @@ impl __Schema { entity: FilterableType::Scalar(Scalar::Opaque), schema: Arc::clone(&schema_rc), }), + __Type::FilterType(FilterTypeType { + entity: FilterableType::List(ListType { + type_: Box::new(__Type::Scalar(Scalar::ID)) + }), + schema: Arc::clone(&schema_rc), + }), + __Type::FilterType(FilterTypeType { + entity: FilterableType::List(ListType { + type_: Box::new(__Type::Scalar(Scalar::Int)) + }), + schema: Arc::clone(&schema_rc), + }), + __Type::FilterType(FilterTypeType { + entity: FilterableType::List(ListType { + type_: Box::new(__Type::Scalar(Scalar::Float)) + }), + schema: Arc::clone(&schema_rc), + }), + __Type::FilterType(FilterTypeType { + entity: FilterableType::List(ListType { + type_: Box::new(__Type::Scalar(Scalar::String(None))) + }), + schema: Arc::clone(&schema_rc), + }), + __Type::FilterType(FilterTypeType { + entity: FilterableType::List(ListType { + type_: Box::new(__Type::Scalar(Scalar::Boolean)) + }), + schema: Arc::clone(&schema_rc), + }), + __Type::FilterType(FilterTypeType { + entity: FilterableType::List(ListType { + type_: Box::new(__Type::Scalar(Scalar::Date)) + }), + schema: Arc::clone(&schema_rc), + }), + __Type::FilterType(FilterTypeType { + entity: FilterableType::List(ListType { + type_: Box::new(__Type::Scalar(Scalar::Time)) + }), + schema: Arc::clone(&schema_rc), + }), + __Type::FilterType(FilterTypeType { + entity: FilterableType::List(ListType { + type_: Box::new(__Type::Scalar(Scalar::Datetime)) + }), + schema: Arc::clone(&schema_rc), + }), + __Type::FilterType(FilterTypeType { + entity: FilterableType::List(ListType { + type_: Box::new(__Type::Scalar(Scalar::BigInt)) + }), + schema: Arc::clone(&schema_rc), + }), + __Type::FilterType(FilterTypeType { + entity: FilterableType::List(ListType { + type_: Box::new(__Type::Scalar(Scalar::UUID)) + }), + schema: Arc::clone(&schema_rc), + }), + __Type::FilterType(FilterTypeType { + entity: FilterableType::List(ListType { + type_: Box::new(__Type::Scalar(Scalar::BigFloat)) + }), + schema: Arc::clone(&schema_rc), + }), __Type::Query(QueryType { schema: Arc::clone(&schema_rc), }), From 809047a34806dfad668e8961d66c205d00542114 Mon Sep 17 00:00:00 2001 From: Mora Date: Tue, 14 May 2024 23:56:06 -0700 Subject: [PATCH 09/29] correcting entity name for list filter --- src/graphql.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/graphql.rs b/src/graphql.rs index f9a814b8..ba1d36f7 100644 --- a/src/graphql.rs +++ b/src/graphql.rs @@ -1130,7 +1130,10 @@ impl FilterTypeType { match &self.entity { FilterableType::Scalar(s) => s.name().expect("scalar name should exist"), FilterableType::Enum(e) => e.name().expect("enum type name should exist"), - FilterableType::List(l) => l.name().expect("list type name should exist"), + FilterableType::List(l) => match l.of_type().unwrap().name() { + None => panic!("inner list type name should exist"), + Some(name) => format!("{}List", name) + }, } } } From ee149f23f603d0b437d514cac7800ddf181246dc Mon Sep 17 00:00:00 2001 From: Mora Date: Wed, 15 May 2024 00:31:55 -0700 Subject: [PATCH 10/29] fixup! adding mock blog posts to seed data --- dockerfiles/db/setup.sql | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/dockerfiles/db/setup.sql b/dockerfiles/db/setup.sql index dfb17e62..12fdf736 100644 --- a/dockerfiles/db/setup.sql +++ b/dockerfiles/db/setup.sql @@ -58,6 +58,7 @@ create table blog_post( blog_id integer not null references blog(id) on delete cascade, title varchar(255) not null, body varchar(10000), + tags TEXT[], status blog_post_status not null, created_at timestamp not null ); @@ -79,5 +80,16 @@ values ((select id from account where email ilike 'a%'), 'A: Blog 3', 'a desc3', now()), ((select id from account where email ilike 'b%'), 'B: Blog 3', 'b desc1', now()); +-- Sample inserts for blog_post +insert into blog_post (blog_id, title, body, tags, status, created_at) +values + ((SELECT id FROM blog WHERE name = 'A: Blog 1'), 'Post 1 in A Blog 1', 'Content for post 1 in A Blog 1', '{"tech", "update"}', 'RELEASED', NOW()), + ((SELECT id FROM blog WHERE name = 'A: Blog 1'), 'Post 2 in A Blog 1', 'Content for post 2 in A Blog 1', '{"announcement", "tech"}', 'PENDING', NOW()), + ((SELECT id FROM blog WHERE name = 'A: Blog 2'), 'Post 1 in A Blog 2', 'Content for post 1 in A Blog 2', '{"personal"}', 'RELEASED', NOW()), + ((SELECT id FROM blog WHERE name = 'A: Blog 2'), 'Post 2 in A Blog 2', 'Content for post 2 in A Blog 2', '{"update"}', 'ARCHIVED', NOW()), + ((SELECT id FROM blog WHERE name = 'A: Blog 3'), 'Post 1 in A Blog 3', 'Content for post 1 in A Blog 3', '{"travel", "adventure"}', 'PENDING', NOW()), + ((SELECT id FROM blog WHERE name = 'B: Blog 3'), 'Post 1 in B Blog 3', 'Content for post 1 in B Blog 3', '{"tech", "review"}', 'RELEASED', NOW()), + ((SELECT id FROM blog WHERE name = 'B: Blog 3'), 'Post 2 in B Blog 3', 'Content for post 2 in B Blog 3', '{"coding", "tutorial"}', 'PENDING', NOW()); + comment on schema public is '@graphql({"inflect_names": true})'; From 9851b3ca59234ad05d627c620cce4d3bf07eab5c Mon Sep 17 00:00:00 2001 From: Mora Date: Wed, 15 May 2024 00:36:57 -0700 Subject: [PATCH 11/29] simplifying array filter builders --- src/builder.rs | 29 +++++++++++++---------------- 1 file changed, 13 insertions(+), 16 deletions(-) diff --git a/src/builder.rs b/src/builder.rs index 847974cb..ef551752 100644 --- a/src/builder.rs +++ b/src/builder.rs @@ -1085,7 +1085,7 @@ fn create_filters( let kv_map = match validated { gson::Value::Absent | gson::Value::Null => return Ok(filters), gson::Value::Object(kv) => kv, - _ => return Err("Filter re-validation errror".to_string()), + _ => return Err("Filter re-validation error".to_string()), }; for (k, op_to_v) in kv_map { @@ -1174,22 +1174,19 @@ fn create_filters( } else { if !values.is_empty() { for value in values { - match value { - gson::Value::Object(filter_op_to_value_map) => { - for (filter_op_str, filter_val) in filter_op_to_value_map { - let filter_op = FilterOp::from_str(filter_op_str)?; - - // Skip absent - // Technically nulls should be treated as literals. It will always filter out all rows - // val null is never true - if filter_val == &gson::Value::Absent { - continue; - } - - filters.push(create_filter_builder_elem(filter_iv, filter_op, filter_val)?); + if let gson::Value::Object(filter_op_to_value_map) = value { + for (filter_op_str, filter_val) in filter_op_to_value_map { + let filter_op = FilterOp::from_str(filter_op_str)?; + + // Skip absent + // Technically nulls should be treated as literals. It will always filter out all rows + // val null is never true + if filter_val == &gson::Value::Absent { + continue; } - }, - _ => return Err("Filter re-validation error op_to_value map".to_string()), + + filters.push(create_filter_builder_elem(filter_iv, filter_op, filter_val)?); + } } } } From 4cc6752f7292442108dc77eb27bfd7746204d068 Mon Sep 17 00:00:00 2001 From: Mora Date: Wed, 15 May 2024 01:36:32 -0700 Subject: [PATCH 12/29] un-nesting list filter --- src/graphql.rs | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/src/graphql.rs b/src/graphql.rs index ba1d36f7..37f591f9 100644 --- a/src/graphql.rs +++ b/src/graphql.rs @@ -3707,13 +3707,9 @@ impl ___Type for FilterEntityType { }), __Type::List(l) => Some(__InputValue { name_: column_graphql_name, - type_: __Type::List(ListType { - type_: Box::new(__Type::NonNull(NonNullType { - type_: Box::new(__Type::FilterType(FilterTypeType { - entity: FilterableType::List(l), - schema: Arc::clone(&self.schema), - })), - })), + type_: __Type::FilterType(FilterTypeType { + entity: FilterableType::List(l), + schema: Arc::clone(&self.schema), }), description: None, default_value: None, From 201154d45d6e2fa68016c109a5efa0b825f80ffa Mon Sep 17 00:00:00 2001 From: Mora Date: Wed, 15 May 2024 01:36:52 -0700 Subject: [PATCH 13/29] unwrapping non-nullable types --- src/graphql.rs | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/src/graphql.rs b/src/graphql.rs index 37f591f9..05565c76 100644 --- a/src/graphql.rs +++ b/src/graphql.rs @@ -3684,17 +3684,19 @@ impl ___Type for FilterEntityType { not_column_exists = true; } - match utype { - __Type::Scalar(s) => Some(__InputValue { - name_: column_graphql_name, - type_: __Type::FilterType(FilterTypeType { - entity: FilterableType::Scalar(s), - schema: Arc::clone(&self.schema), - }), - description: None, - default_value: None, - sql_type: Some(NodeSQLType::Column(Arc::clone(col))), - }), + match utype.nullable_type() { + __Type::Scalar(s) => { + Some(__InputValue { + name_: column_graphql_name, + type_: __Type::FilterType(FilterTypeType { + entity: FilterableType::Scalar(s), + schema: Arc::clone(&self.schema), + }), + description: None, + default_value: None, + sql_type: Some(NodeSQLType::Column(Arc::clone(col))), + }) + }, __Type::Enum(e) => Some(__InputValue { name_: column_graphql_name, type_: __Type::FilterType(FilterTypeType { From a080c4fe517b35b68b46a918e254421580d743d5 Mon Sep 17 00:00:00 2001 From: Mora Date: Wed, 15 May 2024 01:59:24 -0700 Subject: [PATCH 14/29] enabling ordering by array columns --- src/graphql.rs | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/src/graphql.rs b/src/graphql.rs index 05565c76..3efa675e 100644 --- a/src/graphql.rs +++ b/src/graphql.rs @@ -3883,13 +3883,24 @@ impl ___Type for OrderByEntityType { .columns .iter() .filter(|x| x.permissions.is_selectable) - // No filtering on arrays - .filter(|x| !x.type_name.ends_with("[]")) - // No filtering on composites + // Previously, ordering by arrays was not supported, as shown on the next line. + // .filter(|x| !x.type_name.ends_with("[]")) + // However, in response to Issue #460, the line above has been commented out and + // array types are now exposed in the `orderBy` input for collections. + // Per the [latest PostgreSQL docs](https://www.postgresql.org/docs/16/functions-array.html#FUNCTIONS-ARRAY) + // at the time of writing, array comparison/ordering works as follows: + // + // The comparison operators compare the array contents element-by-element, using the + // default B-tree comparison function for the element data type, and sort based on the + // first difference. In multidimensional arrays the elements are visited in row-major + // order (last subscript varies most rapidly). If the contents of two arrays are equal + // but the dimensionality is different, the first difference in the dimensionality + // information determines the sort order. + + // No ordering by composites .filter(|x| !self.schema.context.is_composite(x.type_oid)) - // No filtering on json/b. they do not support = or <> + // No ordering by json/b. they do not support = or <> .filter(|x| !["json", "jsonb"].contains(&x.type_name.as_ref())) - // TODO filter out arrays, json and composites .map(|col| __InputValue { name_: self.schema.graphql_column_field_name(col), type_: __Type::OrderBy(OrderByType {}), From 0a45e97819624d7e32c2e72e68e362a205148dbf Mon Sep 17 00:00:00 2001 From: Mora Date: Wed, 15 May 2024 10:11:09 -0700 Subject: [PATCH 15/29] disabling ordering by array columns --- src/graphql.rs | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-) diff --git a/src/graphql.rs b/src/graphql.rs index 3efa675e..ae4300d8 100644 --- a/src/graphql.rs +++ b/src/graphql.rs @@ -3883,20 +3883,8 @@ impl ___Type for OrderByEntityType { .columns .iter() .filter(|x| x.permissions.is_selectable) - // Previously, ordering by arrays was not supported, as shown on the next line. - // .filter(|x| !x.type_name.ends_with("[]")) - // However, in response to Issue #460, the line above has been commented out and - // array types are now exposed in the `orderBy` input for collections. - // Per the [latest PostgreSQL docs](https://www.postgresql.org/docs/16/functions-array.html#FUNCTIONS-ARRAY) - // at the time of writing, array comparison/ordering works as follows: - // - // The comparison operators compare the array contents element-by-element, using the - // default B-tree comparison function for the element data type, and sort based on the - // first difference. In multidimensional arrays the elements are visited in row-major - // order (last subscript varies most rapidly). If the contents of two arrays are equal - // but the dimensionality is different, the first difference in the dimensionality - // information determines the sort order. - + // No ordering by arrays + .filter(|x| !x.type_name.ends_with("[]")) // No ordering by composites .filter(|x| !self.schema.context.is_composite(x.type_oid)) // No ordering by json/b. they do not support = or <> From 83c5ea9a198d8fec25ac346ed1f2632967793deb Mon Sep 17 00:00:00 2001 From: Mora Date: Wed, 15 May 2024 20:20:31 -0700 Subject: [PATCH 16/29] updating failing tests --- test/expected/omit_exotic_types.out | 6 +- test/expected/omit_weird_names.out | 33 + test/expected/resolve___schema.out | 44 + test/expected/resolve_graphiql_schema.out | 5281 ++++++++++++++------- test/expected/roundtrip_types.out | 352 +- test/sql/omit_exotic_types.sql | 3 +- 6 files changed, 3882 insertions(+), 1837 deletions(-) diff --git a/test/expected/omit_exotic_types.out b/test/expected/omit_exotic_types.out index 545d18c1..4eb94751 100644 --- a/test/expected/omit_exotic_types.out +++ b/test/expected/omit_exotic_types.out @@ -1,8 +1,7 @@ begin; /* - Composite and array types are not currently supported as inputs + Composite types are not currently supported as inputs - confirm composites are not allowed anywhere - - confirm arrays are not allowed as input */ create type complex as (r int, i int); create table something( @@ -107,6 +106,9 @@ begin; { + "name": "name" + }, + + { + + "name": "tags" + + }, + { + "name": "nodeId" + }, + diff --git a/test/expected/omit_weird_names.out b/test/expected/omit_weird_names.out index e756663a..6d6d427d 100644 --- a/test/expected/omit_weird_names.out +++ b/test/expected/omit_weird_names.out @@ -24,18 +24,27 @@ begin; { + "name": "BigFloatFilter" + }, + + { + + "name": "BigFloatListFilter" + + }, + { + "name": "BigInt" + }, + { + "name": "BigIntFilter" + }, + + { + + "name": "BigIntListFilter" + + }, + { + "name": "Boolean" + }, + { + "name": "BooleanFilter" + }, + + { + + "name": "BooleanListFilter" + + }, + { + "name": "Cursor" + }, + @@ -45,12 +54,18 @@ begin; { + "name": "DateFilter" + }, + + { + + "name": "DateListFilter" + + }, + { + "name": "Datetime" + }, + { + "name": "DatetimeFilter" + }, + + { + + "name": "DatetimeListFilter" + + }, + { + "name": "FilterIs" + }, + @@ -60,18 +75,27 @@ begin; { + "name": "FloatFilter" + }, + + { + + "name": "FloatListFilter" + + }, + { + "name": "ID" + }, + { + "name": "IDFilter" + }, + + { + + "name": "IDListFilter" + + }, + { + "name": "Int" + }, + { + "name": "IntFilter" + }, + + { + + "name": "IntListFilter" + + }, + { + "name": "JSON" + }, + @@ -99,18 +123,27 @@ begin; { + "name": "StringFilter" + }, + + { + + "name": "StringListFilter" + + }, + { + "name": "Time" + }, + { + "name": "TimeFilter" + }, + + { + + "name": "TimeListFilter" + + }, + { + "name": "UUID" + }, + { + "name": "UUIDFilter" + }, + + { + + "name": "UUIDListFilter" + + }, + { + "name": "__Directive" + }, + diff --git a/test/expected/resolve___schema.out b/test/expected/resolve___schema.out index 2abc049e..77f82d7f 100644 --- a/test/expected/resolve___schema.out +++ b/test/expected/resolve___schema.out @@ -101,6 +101,10 @@ begin; "kind": "INPUT_OBJECT", + "name": "BigFloatFilter" + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "BigFloatListFilter" + + }, + { + "kind": "SCALAR", + "name": "BigInt" + @@ -109,6 +113,10 @@ begin; "kind": "INPUT_OBJECT", + "name": "BigIntFilter" + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "BigIntListFilter" + + }, + { + "kind": "OBJECT", + "name": "Blog" + @@ -205,6 +213,10 @@ begin; "kind": "INPUT_OBJECT", + "name": "BooleanFilter" + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "BooleanListFilter" + + }, + { + "kind": "SCALAR", + "name": "Cursor" + @@ -217,6 +229,10 @@ begin; "kind": "INPUT_OBJECT", + "name": "DateFilter" + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "DateListFilter" + + }, + { + "kind": "SCALAR", + "name": "Datetime" + @@ -225,6 +241,10 @@ begin; "kind": "INPUT_OBJECT", + "name": "DatetimeFilter" + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "DatetimeListFilter" + + }, + { + "kind": "ENUM", + "name": "FilterIs" + @@ -237,6 +257,10 @@ begin; "kind": "INPUT_OBJECT", + "name": "FloatFilter" + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "FloatListFilter" + + }, + { + "kind": "SCALAR", + "name": "ID" + @@ -245,6 +269,10 @@ begin; "kind": "INPUT_OBJECT", + "name": "IDFilter" + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "IDListFilter" + + }, + { + "kind": "SCALAR", + "name": "Int" + @@ -253,6 +281,10 @@ begin; "kind": "INPUT_OBJECT", + "name": "IntFilter" + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "IntListFilter" + + }, + { + "kind": "SCALAR", + "name": "JSON" + @@ -293,6 +325,10 @@ begin; "kind": "INPUT_OBJECT", + "name": "StringFilter" + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "StringListFilter" + + }, + { + "kind": "SCALAR", + "name": "Time" + @@ -301,6 +337,10 @@ begin; "kind": "INPUT_OBJECT", + "name": "TimeFilter" + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "TimeListFilter" + + }, + { + "kind": "SCALAR", + "name": "UUID" + @@ -309,6 +349,10 @@ begin; "kind": "INPUT_OBJECT", + "name": "UUIDFilter" + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "UUIDListFilter" + + }, + { + "kind": "OBJECT", + "name": "__Directive" + diff --git a/test/expected/resolve_graphiql_schema.out b/test/expected/resolve_graphiql_schema.out index bbacd6a7..213ca9ad 100644 --- a/test/expected/resolve_graphiql_schema.out +++ b/test/expected/resolve_graphiql_schema.out @@ -1056,6 +1056,181 @@ begin; ], + "possibleTypes": null + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "BigFloatListFilter", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "Boolean expression comparing fields on type \"BigFloatList\"", + + "inputFields": [ + + { + + "name": "cd", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigFloat", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "cs", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigFloat", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "eq", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigFloat", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "gt", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigFloat", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "gte", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigFloat", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "lt", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigFloat", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "lte", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigFloat", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "neq", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigFloat", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "ov", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigFloat", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + } + + ], + + "possibleTypes": null + + }, + { + "kind": "SCALAR", + "name": "BigInt", + @@ -1170,76 +1345,251 @@ begin; "possibleTypes": null + }, + { + - "kind": "OBJECT", + - "name": "Blog", + - "fields": [ + + "kind": "INPUT_OBJECT", + + "name": "BigIntListFilter", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "Boolean expression comparing fields on type \"BigIntList\"", + + "inputFields": [ + { + - "args": [ + - ], + - "name": "nodeId", + + "name": "cd", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "SCALAR", + - "name": "ID", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigInt", + + "ofType": null + + } + } + }, + - "description": "Globally Unique Record Identifier", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "id", + + "name": "cs", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigInt", + + "ofType": null + + } + } + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "ownerId", + + "name": "eq", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigInt", + + "ofType": null + + } + } + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "name", + + "name": "gt", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigInt", + + "ofType": null + + } + } + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + + }, + + { + + "name": "gte", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigInt", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "lt", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigInt", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "lte", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigInt", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "neq", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigInt", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "ov", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "BigInt", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + } + + ], + + "possibleTypes": null + + }, + + { + + "kind": "OBJECT", + + "name": "Blog", + + "fields": [ + + { + + "args": [ + + ], + + "name": "nodeId", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + + } + + }, + + "description": "Globally Unique Record Identifier", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "id", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "ownerId", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "name", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + } + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + }, + { + "args": [ + @@ -1655,6 +2005,16 @@ begin; "description": null, + "defaultValue": null + }, + + { + + "name": "tags", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "StringListFilter", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + { + "name": "createdAt", + "type": { + @@ -3023,72 +3383,72 @@ begin; ], + "possibleTypes": null + }, + - { + - "kind": "SCALAR", + - "name": "Cursor", + - "fields": null, + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": "An opaque string using for tracking a position in results during pagination", + - "inputFields": null, + - "possibleTypes": null + - }, + - { + - "kind": "SCALAR", + - "name": "Date", + - "fields": null, + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": "A date wihout time information", + - "inputFields": null, + - "possibleTypes": null + - }, + { + "kind": "INPUT_OBJECT", + - "name": "DateFilter", + + "name": "BooleanListFilter", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "Boolean expression comparing fields on type \"Date\"", + + "description": "Boolean expression comparing fields on type \"BooleanList\"", + "inputFields": [ + { + - "name": "eq", + + "name": "cd", + "type": { + - "kind": "SCALAR", + - "name": "Date", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Boolean", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "gt", + + "name": "cs", + "type": { + - "kind": "SCALAR", + - "name": "Date", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Boolean", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "gte", + + "name": "eq", + "type": { + - "kind": "SCALAR", + - "name": "Date", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Boolean", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "in", + + "name": "gt", + "type": { + "kind": "LIST", + "name": null, + @@ -3097,7 +3457,7 @@ begin; "name": null, + "ofType": { + "kind": "SCALAR", + - "name": "Date", + + "name": "Boolean", + "ofType": null + } + } + @@ -3106,21 +3466,37 @@ begin; "defaultValue": null + }, + { + - "name": "is", + + "name": "gte", + "type": { + - "kind": "ENUM", + - "name": "FilterIs", + - "ofType": null + - }, + - "description": null, + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Boolean", + + "ofType": null + + } + + } + + }, + + "description": null, + "defaultValue": null + }, + { + "name": "lt", + "type": { + - "kind": "SCALAR", + - "name": "Date", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Boolean", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + @@ -3128,9 +3504,17 @@ begin; { + "name": "lte", + "type": { + - "kind": "SCALAR", + - "name": "Date", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Boolean", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + @@ -3138,9 +3522,35 @@ begin; { + "name": "neq", + "type": { + - "kind": "SCALAR", + - "name": "Date", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Boolean", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "ov", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Boolean", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + @@ -3150,31 +3560,43 @@ begin; }, + { + "kind": "SCALAR", + - "name": "Datetime", + + "name": "Cursor", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "A date and time", + + "description": "An opaque string using for tracking a position in results during pagination", + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "SCALAR", + + "name": "Date", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "A date wihout time information", + "inputFields": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + - "name": "DatetimeFilter", + + "name": "DateFilter", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "Boolean expression comparing fields on type \"Datetime\"", + + "description": "Boolean expression comparing fields on type \"Date\"", + "inputFields": [ + { + "name": "eq", + "type": { + "kind": "SCALAR", + - "name": "Datetime", + + "name": "Date", + "ofType": null + }, + "description": null, + @@ -3184,7 +3606,7 @@ begin; "name": "gt", + "type": { + "kind": "SCALAR", + - "name": "Datetime", + + "name": "Date", + "ofType": null + }, + "description": null, + @@ -3194,7 +3616,7 @@ begin; "name": "gte", + "type": { + "kind": "SCALAR", + - "name": "Datetime", + + "name": "Date", + "ofType": null + }, + "description": null, + @@ -3210,7 +3632,7 @@ begin; "name": null, + "ofType": { + "kind": "SCALAR", + - "name": "Datetime", + + "name": "Date", + "ofType": null + } + } + @@ -3232,7 +3654,7 @@ begin; "name": "lt", + "type": { + "kind": "SCALAR", + - "name": "Datetime", + + "name": "Date", + "ofType": null + }, + "description": null, + @@ -3242,7 +3664,7 @@ begin; "name": "lte", + "type": { + "kind": "SCALAR", + - "name": "Datetime", + + "name": "Date", + "ofType": null + }, + "description": null, + @@ -3252,7 +3674,7 @@ begin; "name": "neq", + "type": { + "kind": "SCALAR", + - "name": "Datetime", + + "name": "Date", + "ofType": null + }, + "description": null, + @@ -3261,84 +3683,72 @@ begin; ], + "possibleTypes": null + }, + - { + - "kind": "ENUM", + - "name": "FilterIs", + - "fields": null, + - "enumValues": [ + - { + - "name": "NULL", + - "description": null, + - "isDeprecated": false, + - "deprecationReason": null + - }, + - { + - "name": "NOT_NULL", + - "description": null, + - "isDeprecated": false, + - "deprecationReason": null + - } + - ], + - "interfaces": [ + - ], + - "description": null, + - "inputFields": null, + - "possibleTypes": null + - }, + - { + - "kind": "SCALAR", + - "name": "Float", + - "fields": null, + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": "A scalar floating point value up to 32 bits", + - "inputFields": null, + - "possibleTypes": null + - }, + { + "kind": "INPUT_OBJECT", + - "name": "FloatFilter", + + "name": "DateListFilter", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "Boolean expression comparing fields on type \"Float\"", + + "description": "Boolean expression comparing fields on type \"DateList\"", + "inputFields": [ + { + - "name": "eq", + + "name": "cd", + "type": { + - "kind": "SCALAR", + - "name": "Float", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Date", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "gt", + + "name": "cs", + "type": { + - "kind": "SCALAR", + - "name": "Float", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Date", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "gte", + + "name": "eq", + "type": { + - "kind": "SCALAR", + - "name": "Float", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Date", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "in", + + "name": "gt", + "type": { + "kind": "LIST", + "name": null, + @@ -3347,7 +3757,7 @@ begin; "name": null, + "ofType": { + "kind": "SCALAR", + - "name": "Float", + + "name": "Date", + "ofType": null + } + } + @@ -3356,11 +3766,19 @@ begin; "defaultValue": null + }, + { + - "name": "is", + + "name": "gte", + "type": { + - "kind": "ENUM", + - "name": "FilterIs", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Date", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + @@ -3368,9 +3786,17 @@ begin; { + "name": "lt", + "type": { + - "kind": "SCALAR", + - "name": "Float", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Date", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + @@ -3378,9 +3804,17 @@ begin; { + "name": "lte", + "type": { + - "kind": "SCALAR", + - "name": "Float", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Date", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + @@ -3388,44 +3822,35 @@ begin; { + "name": "neq", + "type": { + - "kind": "SCALAR", + - "name": "Float", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Date", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + - } + - ], + - "possibleTypes": null + - }, + - { + - "kind": "SCALAR", + - "name": "ID", + - "fields": null, + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": "A globally unique identifier for a given record", + - "inputFields": null, + - "possibleTypes": null + - }, + - { + - "kind": "INPUT_OBJECT", + - "name": "IDFilter", + - "fields": null, + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": "Boolean expression comparing fields on type \"ID\"", + - "inputFields": [ + + }, + { + - "name": "eq", + + "name": "ov", + "type": { + - "kind": "SCALAR", + - "name": "ID", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Date", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + @@ -3435,31 +3860,31 @@ begin; }, + { + "kind": "SCALAR", + - "name": "Int", + + "name": "Datetime", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "A scalar integer up to 32 bits", + + "description": "A date and time", + "inputFields": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + - "name": "IntFilter", + + "name": "DatetimeFilter", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "Boolean expression comparing fields on type \"Int\"", + + "description": "Boolean expression comparing fields on type \"Datetime\"", + "inputFields": [ + { + "name": "eq", + "type": { + "kind": "SCALAR", + - "name": "Int", + + "name": "Datetime", + "ofType": null + }, + "description": null, + @@ -3469,7 +3894,7 @@ begin; "name": "gt", + "type": { + "kind": "SCALAR", + - "name": "Int", + + "name": "Datetime", + "ofType": null + }, + "description": null, + @@ -3479,7 +3904,7 @@ begin; "name": "gte", + "type": { + "kind": "SCALAR", + - "name": "Int", + + "name": "Datetime", + "ofType": null + }, + "description": null, + @@ -3495,7 +3920,7 @@ begin; "name": null, + "ofType": { + "kind": "SCALAR", + - "name": "Int", + + "name": "Datetime", + "ofType": null + } + } + @@ -3517,7 +3942,7 @@ begin; "name": "lt", + "type": { + "kind": "SCALAR", + - "name": "Int", + + "name": "Datetime", + "ofType": null + }, + "description": null, + @@ -3527,7 +3952,7 @@ begin; "name": "lte", + "type": { + "kind": "SCALAR", + - "name": "Int", + + "name": "Datetime", + "ofType": null + }, + "description": null, + @@ -3537,7 +3962,7 @@ begin; "name": "neq", + "type": { + "kind": "SCALAR", + - "name": "Int", + + "name": "Datetime", + "ofType": null + }, + "description": null, + @@ -3547,1179 +3972,647 @@ begin; "possibleTypes": null + }, + { + - "kind": "SCALAR", + - "name": "JSON", + + "kind": "INPUT_OBJECT", + + "name": "DatetimeListFilter", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "A Javascript Object Notation value serialized as a string", + - "inputFields": null, + - "possibleTypes": null + - }, + - { + - "kind": "OBJECT", + - "name": "Mutation", + - "fields": [ + + "description": "Boolean expression comparing fields on type \"DatetimeList\"", + + "inputFields": [ + { + - "args": [ + - { + - "name": "filter", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "AccountFilter", + - "ofType": null + - }, + - "description": "Restricts the mutation's impact to records matching the criteria", + - "defaultValue": null + - }, + - { + - "name": "atMost", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - } + - }, + - "description": "The maximum number of records in the collection permitted to be affected", + - "defaultValue": "1" + - } + - ], + - "name": "deleteFromAccountCollection", + + "name": "cd", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "OBJECT", + - "name": "AccountDeleteResponse", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + } + } + }, + - "description": "Deletes zero or more records from the `Account` collection", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + }, + { + - "args": [ + - { + - "name": "filter", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "BlogFilter", + - "ofType": null + - }, + - "description": "Restricts the mutation's impact to records matching the criteria", + - "defaultValue": null + - }, + - { + - "name": "atMost", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - } + - }, + - "description": "The maximum number of records in the collection permitted to be affected", + - "defaultValue": "1" + - } + - ], + - "name": "deleteFromBlogCollection", + + "name": "cs", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "OBJECT", + - "name": "BlogDeleteResponse", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + } + } + }, + - "description": "Deletes zero or more records from the `Blog` collection", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + }, + { + - "args": [ + - { + - "name": "filter", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "BlogPostFilter", + - "ofType": null + - }, + - "description": "Restricts the mutation's impact to records matching the criteria", + - "defaultValue": null + - }, + - { + - "name": "atMost", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - } + - }, + - "description": "The maximum number of records in the collection permitted to be affected", + - "defaultValue": "1" + - } + - ], + - "name": "deleteFromBlogPostCollection", + + "name": "eq", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "OBJECT", + - "name": "BlogPostDeleteResponse", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + } + } + }, + - "description": "Deletes zero or more records from the `BlogPost` collection", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + }, + { + - "args": [ + - { + - "name": "filter", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "PersonFilter", + - "ofType": null + - }, + - "description": "Restricts the mutation's impact to records matching the criteria", + - "defaultValue": null + - }, + - { + - "name": "atMost", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - } + - }, + - "description": "The maximum number of records in the collection permitted to be affected", + - "defaultValue": "1" + - } + - ], + - "name": "deleteFromPersonCollection", + + "name": "gt", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "OBJECT", + - "name": "PersonDeleteResponse", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + } + } + }, + - "description": "Deletes zero or more records from the `Person` collection", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + }, + { + - "args": [ + - { + - "name": "objects", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "LIST", + - "name": null, + - "ofType": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "AccountInsertInput", + - "ofType": null + - } + - } + - } + - }, + - "description": null, + - "defaultValue": null + - } + - ], + - "name": "insertIntoAccountCollection", + + "name": "gte", + "type": { + - "kind": "OBJECT", + - "name": "AccountInsertResponse", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + } + + } + }, + - "description": "Adds one or more `Account` records to the collection", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + }, + { + - "args": [ + - { + - "name": "objects", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "LIST", + - "name": null, + - "ofType": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "BlogInsertInput", + - "ofType": null + - } + - } + - } + - }, + - "description": null, + - "defaultValue": null + - } + - ], + - "name": "insertIntoBlogCollection", + + "name": "lt", + "type": { + - "kind": "OBJECT", + - "name": "BlogInsertResponse", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + } + + } + }, + - "description": "Adds one or more `Blog` records to the collection", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + }, + { + - "args": [ + - { + - "name": "objects", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "LIST", + - "name": null, + - "ofType": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "BlogPostInsertInput", + - "ofType": null + - } + - } + - } + - }, + - "description": null, + - "defaultValue": null + - } + - ], + - "name": "insertIntoBlogPostCollection", + + "name": "lte", + "type": { + - "kind": "OBJECT", + - "name": "BlogPostInsertResponse", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + } + + } + }, + - "description": "Adds one or more `BlogPost` records to the collection", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + }, + { + - "args": [ + - { + - "name": "objects", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "LIST", + - "name": null, + - "ofType": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "PersonInsertInput", + - "ofType": null + - } + - } + - } + - }, + - "description": null, + - "defaultValue": null + - } + - ], + - "name": "insertIntoPersonCollection", + + "name": "neq", + "type": { + - "kind": "OBJECT", + - "name": "PersonInsertResponse", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + } + + } + }, + - "description": "Adds one or more `Person` records to the collection", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + }, + { + - "args": [ + - { + - "name": "set", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "AccountUpdateInput", + - "ofType": null + - } + - }, + - "description": "Fields that are set will be updated for all records matching the `filter`", + - "defaultValue": null + - }, + - { + - "name": "filter", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "AccountFilter", + - "ofType": null + - }, + - "description": "Restricts the mutation's impact to records matching the criteria", + - "defaultValue": null + - }, + - { + - "name": "atMost", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - } + - }, + - "description": "The maximum number of records in the collection permitted to be affected", + - "defaultValue": "1" + - } + - ], + - "name": "updateAccountCollection", + + "name": "ov", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "OBJECT", + - "name": "AccountUpdateResponse", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + } + } + }, + - "description": "Updates zero or more records in the `Account` collection", + + "description": null, + + "defaultValue": null + + } + + ], + + "possibleTypes": null + + }, + + { + + "kind": "ENUM", + + "name": "FilterIs", + + "fields": null, + + "enumValues": [ + + { + + "name": "NULL", + + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + - "args": [ + - { + - "name": "set", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "BlogUpdateInput", + - "ofType": null + - } + - }, + - "description": "Fields that are set will be updated for all records matching the `filter`", + - "defaultValue": null + - }, + - { + - "name": "filter", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "BlogFilter", + - "ofType": null + - }, + - "description": "Restricts the mutation's impact to records matching the criteria", + - "defaultValue": null + - }, + - { + - "name": "atMost", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - } + - }, + - "description": "The maximum number of records in the collection permitted to be affected", + - "defaultValue": "1" + - } + - ], + - "name": "updateBlogCollection", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "OBJECT", + - "name": "BlogUpdateResponse", + - "ofType": null + - } + - }, + - "description": "Updates zero or more records in the `Blog` collection", + - "isDeprecated": false, + - "deprecationReason": null + - }, + - { + - "args": [ + - { + - "name": "set", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "BlogPostUpdateInput", + - "ofType": null + - } + - }, + - "description": "Fields that are set will be updated for all records matching the `filter`", + - "defaultValue": null + - }, + - { + - "name": "filter", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "BlogPostFilter", + - "ofType": null + - }, + - "description": "Restricts the mutation's impact to records matching the criteria", + - "defaultValue": null + - }, + - { + - "name": "atMost", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - } + - }, + - "description": "The maximum number of records in the collection permitted to be affected", + - "defaultValue": "1" + - } + - ], + - "name": "updateBlogPostCollection", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "OBJECT", + - "name": "BlogPostUpdateResponse", + - "ofType": null + - } + - }, + - "description": "Updates zero or more records in the `BlogPost` collection", + - "isDeprecated": false, + - "deprecationReason": null + - }, + - { + - "args": [ + - { + - "name": "set", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "PersonUpdateInput", + - "ofType": null + - } + - }, + - "description": "Fields that are set will be updated for all records matching the `filter`", + - "defaultValue": null + - }, + - { + - "name": "filter", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "PersonFilter", + - "ofType": null + - }, + - "description": "Restricts the mutation's impact to records matching the criteria", + - "defaultValue": null + - }, + - { + - "name": "atMost", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - } + - }, + - "description": "The maximum number of records in the collection permitted to be affected", + - "defaultValue": "1" + - } + - ], + - "name": "updatePersonCollection", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "OBJECT", + - "name": "PersonUpdateResponse", + - "ofType": null + - } + - }, + - "description": "Updates zero or more records in the `Person` collection", + - "isDeprecated": false, + - "deprecationReason": null + - } + - ], + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": "The root type for creating and mutating data", + - "inputFields": null, + - "possibleTypes": null + - }, + - { + - "kind": "INTERFACE", + - "name": "Node", + - "fields": [ + - { + - "args": [ + - ], + - "name": "nodeId", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "ID", + - "ofType": null + - } + - }, + - "description": "Retrieves a record by `ID`", + + "name": "NOT_NULL", + + "description": null, + "isDeprecated": false, + "deprecationReason": null + } + ], + - "enumValues": [ + - ], + "interfaces": [ + ], + "description": null, + "inputFields": null, + - "possibleTypes": [ + - { + - "kind": "OBJECT", + - "name": "Account", + - "ofType": null + - }, + - { + - "kind": "OBJECT", + - "name": "Blog", + - "ofType": null + - }, + - { + - "kind": "OBJECT", + - "name": "BlogPost", + - "ofType": null + - }, + - { + - "kind": "OBJECT", + - "name": "Person", + - "ofType": null + - } + - ] + + "possibleTypes": null + }, + { + "kind": "SCALAR", + - "name": "Opaque", + + "name": "Float", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "Any type not handled by the type system", + + "description": "A scalar floating point value up to 32 bits", + "inputFields": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + - "name": "OpaqueFilter", + + "name": "FloatFilter", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "Boolean expression comparing fields on type \"Opaque\"", + + "description": "Boolean expression comparing fields on type \"Float\"", + "inputFields": [ + { + "name": "eq", + "type": { + "kind": "SCALAR", + - "name": "Opaque", + + "name": "Float", + "ofType": null + }, + "description": null, + "defaultValue": null + }, + { + - "name": "is", + + "name": "gt", + "type": { + - "kind": "ENUM", + - "name": "FilterIs", + + "kind": "SCALAR", + + "name": "Float", + "ofType": null + }, + "description": null, + "defaultValue": null + - } + - ], + - "possibleTypes": null + - }, + - { + - "kind": "ENUM", + - "name": "OrderByDirection", + - "fields": null, + - "enumValues": [ + - { + - "name": "AscNullsFirst", + - "description": "Ascending order, nulls first", + - "isDeprecated": false, + - "deprecationReason": null + - }, + - { + - "name": "AscNullsLast", + - "description": "Ascending order, nulls last", + - "isDeprecated": false, + - "deprecationReason": null + }, + { + - "name": "DescNullsFirst", + - "description": "Descending order, nulls first", + - "isDeprecated": false, + - "deprecationReason": null + + "name": "gte", + + "type": { + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + }, + { + - "name": "DescNullsLast", + - "description": "Descending order, nulls last", + - "isDeprecated": false, + - "deprecationReason": null + - } + - ], + - "interfaces": [ + - ], + - "description": "Defines a per-field sorting order", + - "inputFields": null, + - "possibleTypes": null + - }, + - { + - "kind": "OBJECT", + - "name": "PageInfo", + - "fields": [ + + "name": "in", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + { + - "args": [ + - ], + - "name": "endCursor", + + "name": "is", + "type": { + - "kind": "SCALAR", + - "name": "String", + + "kind": "ENUM", + + "name": "FilterIs", + "ofType": null + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "hasNextPage", + + "name": "lt", + "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Boolean", + - "ofType": null + - } + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "hasPreviousPage", + + "name": "lte", + "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Boolean", + - "ofType": null + - } + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "startCursor", + + "name": "neq", + "type": { + "kind": "SCALAR", + - "name": "String", + + "name": "Float", + "ofType": null + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + } + ], + + "possibleTypes": null + + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "FloatListFilter", + + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": null, + - "inputFields": null, + - "possibleTypes": null + - }, + - { + - "kind": "OBJECT", + - "name": "Person", + - "fields": [ + + "description": "Boolean expression comparing fields on type \"FloatList\"", + + "inputFields": [ + { + - "args": [ + - ], + - "name": "nodeId", + + "name": "cd", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "SCALAR", + - "name": "ID", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + + } + } + }, + - "description": "Globally Unique Record Identifier", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "id", + + "name": "cs", + "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + + } + + } + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "email", + + "name": "eq", + "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + + } + + } + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "encryptedPassword", + + "name": "gt", + "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + + } + + } + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "createdAt", + + "name": "gte", + "type": { + - "kind": "SCALAR", + - "name": "Datetime", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + + } + + } + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "updatedAt", + + "name": "lt", + "type": { + - "kind": "SCALAR", + - "name": "Datetime", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + + } + + } + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + }, + { + - "args": [ + - { + - "name": "first", + - "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - }, + - "description": "Query the first `n` records in the collection", + - "defaultValue": null + - }, + - { + - "name": "last", + - "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - }, + - "description": "Query the last `n` records in the collection", + - "defaultValue": null + - }, + - { + - "name": "before", + - "type": { + + "name": "lte", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + "kind": "SCALAR", + - "name": "Cursor", + + "name": "Float", + "ofType": null + - }, + - "description": "Query values in the collection before the provided cursor", + - "defaultValue": null + - }, + - { + - "name": "after", + - "type": { + - "kind": "SCALAR", + - "name": "Cursor", + - "ofType": null + - }, + - "description": "Query values in the collection after the provided cursor", + - "defaultValue": null + - }, + - { + - "name": "offset", + - "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - }, + - "description": "Skip n values from the after cursor. Alternative to cursor pagination. Backward pagination not supported.", + - "defaultValue": null + - }, + - { + - "name": "filter", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "BlogFilter", + - "ofType": null + - }, + - "description": "Filters to apply to the results set when querying from the collection", + - "defaultValue": null + - }, + - { + - "name": "orderBy", + - "type": { + - "kind": "LIST", + - "name": null, + - "ofType": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "BlogOrderBy", + - "ofType": null + - } + - } + - }, + - "description": "Sort order to apply to the collection", + - "defaultValue": null + + } + } + - ], + - "name": "blogs", + - "type": { + - "kind": "OBJECT", + - "name": "BlogConnection", + - "ofType": null + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + - } + - ], + - "enumValues": [ + - ], + - "interfaces": [ + - { + - "kind": "INTERFACE", + - "name": "Node", + - "ofType": null + - } + - ], + - "description": null, + - "inputFields": null, + - "possibleTypes": null + - }, + - { + - "kind": "OBJECT", + - "name": "PersonConnection", + - "fields": [ + + "defaultValue": null + + }, + { + - "args": [ + - ], + - "name": "edges", + + "name": "neq", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "LIST", + + "kind": "NON_NULL", + "name": null, + "ofType": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "OBJECT", + - "name": "PersonEdge", + - "ofType": null + - } + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + } + } + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "pageInfo", + + "name": "ov", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "OBJECT", + - "name": "PageInfo", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Float", + + "ofType": null + + } + } + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + } + ], + + "possibleTypes": null + + }, + + { + + "kind": "SCALAR", + + "name": "ID", + + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": null, + + "description": "A globally unique identifier for a given record", + "inputFields": null, + "possibleTypes": null + }, + { + - "kind": "OBJECT", + - "name": "PersonDeleteResponse", + - "fields": [ + - { + - "args": [ + - ], + - "name": "affectedCount", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - } + - }, + - "description": "Count of the records impacted by the mutation", + - "isDeprecated": false, + - "deprecationReason": null + - }, + - { + - "args": [ + - ], + - "name": "records", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "LIST", + - "name": null, + - "ofType": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "OBJECT", + - "name": "Person", + - "ofType": null + - } + - } + - } + - }, + - "description": "Array of records impacted by the mutation", + - "isDeprecated": false, + - "deprecationReason": null + - } + - ], + + "kind": "INPUT_OBJECT", + + "name": "IDFilter", + + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": null, + - "inputFields": null, + - "possibleTypes": null + - }, + - { + - "kind": "OBJECT", + - "name": "PersonEdge", + - "fields": [ + - { + - "args": [ + - ], + - "name": "cursor", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + - } + - }, + - "description": null, + - "isDeprecated": false, + - "deprecationReason": null + - }, + + "description": "Boolean expression comparing fields on type \"ID\"", + + "inputFields": [ + { + - "args": [ + - ], + - "name": "node", + + "name": "eq", + "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "OBJECT", + - "name": "Person", + - "ofType": null + - } + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + }, + "description": null, + - "isDeprecated": false, + - "deprecationReason": null + + "defaultValue": null + } + ], + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": null, + - "inputFields": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + - "name": "PersonFilter", + + "name": "IDListFilter", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": null, + + "description": "Boolean expression comparing fields on type \"IDList\"", + "inputFields": [ + { + - "name": "id", + + "name": "cd", + "type": { + - "kind": "INPUT_OBJECT", + - "name": "IntFilter", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "email", + + "name": "cs", + "type": { + - "kind": "INPUT_OBJECT", + - "name": "StringFilter", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "encryptedPassword", + + "name": "eq", + "type": { + - "kind": "INPUT_OBJECT", + - "name": "StringFilter", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "createdAt", + + "name": "gt", + "type": { + - "kind": "INPUT_OBJECT", + - "name": "DatetimeFilter", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "updatedAt", + + "name": "gte", + "type": { + - "kind": "INPUT_OBJECT", + - "name": "DatetimeFilter", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "nodeId", + + "name": "lt", + "type": { + - "kind": "INPUT_OBJECT", + - "name": "IDFilter", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "and", + + "name": "lte", + "type": { + "kind": "LIST", + "name": null, + @@ -4727,17 +4620,17 @@ begin; "kind": "NON_NULL", + "name": null, + "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "PersonFilter", + + "kind": "SCALAR", + + "name": "ID", + "ofType": null + } + } + }, + - "description": "Returns true only if all its inner filters are true, otherwise returns false", + + "description": null, + "defaultValue": null + }, + { + - "name": "or", + + "name": "neq", + "type": { + "kind": "LIST", + "name": null, + @@ -4745,40 +4638,60 @@ begin; "kind": "NON_NULL", + "name": null, + "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "PersonFilter", + + "kind": "SCALAR", + + "name": "ID", + "ofType": null + } + } + }, + - "description": "Returns true if at least one of its inner filters is true, otherwise returns false", + + "description": null, + "defaultValue": null + }, + { + - "name": "not", + + "name": "ov", + "type": { + - "kind": "INPUT_OBJECT", + - "name": "PersonFilter", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + + } + + } + }, + - "description": "Negates a filter", + + "description": null, + "defaultValue": null + } + ], + "possibleTypes": null + }, + + { + + "kind": "SCALAR", + + "name": "Int", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "A scalar integer up to 32 bits", + + "inputFields": null, + + "possibleTypes": null + + }, + { + "kind": "INPUT_OBJECT", + - "name": "PersonInsertInput", + + "name": "IntFilter", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": null, + + "description": "Boolean expression comparing fields on type \"Int\"", + "inputFields": [ + { + - "name": "id", + + "name": "eq", + "type": { + "kind": "SCALAR", + "name": "Int", + @@ -4788,158 +4701,78 @@ begin; "defaultValue": null + }, + { + - "name": "email", + - "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + - }, + - "description": null, + - "defaultValue": null + - }, + - { + - "name": "encryptedPassword", + - "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + - }, + - "description": null, + - "defaultValue": null + - }, + - { + - "name": "createdAt", + + "name": "gt", + "type": { + "kind": "SCALAR", + - "name": "Datetime", + + "name": "Int", + "ofType": null + }, + "description": null, + "defaultValue": null + }, + { + - "name": "updatedAt", + + "name": "gte", + "type": { + "kind": "SCALAR", + - "name": "Datetime", + + "name": "Int", + "ofType": null + }, + "description": null, + "defaultValue": null + - } + - ], + - "possibleTypes": null + - }, + - { + - "kind": "OBJECT", + - "name": "PersonInsertResponse", + - "fields": [ + - { + - "args": [ + - ], + - "name": "affectedCount", + - "type": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - } + - }, + - "description": "Count of the records impacted by the mutation", + - "isDeprecated": false, + - "deprecationReason": null + }, + { + - "args": [ + - ], + - "name": "records", + + "name": "in", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "LIST", + + "kind": "NON_NULL", + "name": null, + "ofType": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "OBJECT", + - "name": "Person", + - "ofType": null + - } + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + } + } + }, + - "description": "Array of records impacted by the mutation", + - "isDeprecated": false, + - "deprecationReason": null + - } + - ], + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": null, + - "inputFields": null, + - "possibleTypes": null + - }, + - { + - "kind": "INPUT_OBJECT", + - "name": "PersonOrderBy", + - "fields": null, + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": null, + - "inputFields": [ + - { + - "name": "id", + - "type": { + - "kind": "ENUM", + - "name": "OrderByDirection", + - "ofType": null + - }, + "description": null, + "defaultValue": null + }, + { + - "name": "email", + + "name": "is", + "type": { + "kind": "ENUM", + - "name": "OrderByDirection", + + "name": "FilterIs", + "ofType": null + }, + "description": null, + "defaultValue": null + }, + { + - "name": "encryptedPassword", + + "name": "lt", + "type": { + - "kind": "ENUM", + - "name": "OrderByDirection", + + "kind": "SCALAR", + + "name": "Int", + "ofType": null + }, + "description": null, + "defaultValue": null + }, + { + - "name": "createdAt", + + "name": "lte", + "type": { + - "kind": "ENUM", + - "name": "OrderByDirection", + + "kind": "SCALAR", + + "name": "Int", + "ofType": null + }, + "description": null, + "defaultValue": null + }, + { + - "name": "updatedAt", + + "name": "neq", + "type": { + - "kind": "ENUM", + - "name": "OrderByDirection", + + "kind": "SCALAR", + + "name": "Int", + "ofType": null + }, + "description": null, + @@ -4950,178 +4783,197 @@ begin; }, + { + "kind": "INPUT_OBJECT", + - "name": "PersonUpdateInput", + + "name": "IntListFilter", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": null, + + "description": "Boolean expression comparing fields on type \"IntList\"", + "inputFields": [ + { + - "name": "id", + + "name": "cd", + "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "email", + + "name": "cs", + "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + - }, + - "description": null, + - "defaultValue": null + - }, + - { + - "name": "encryptedPassword", + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "eq", + "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "createdAt", + + "name": "gt", + "type": { + - "kind": "SCALAR", + - "name": "Datetime", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "updatedAt", + + "name": "gte", + "type": { + - "kind": "SCALAR", + - "name": "Datetime", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + - } + - ], + - "possibleTypes": null + - }, + - { + - "kind": "OBJECT", + - "name": "PersonUpdateResponse", + - "fields": [ + + }, + { + - "args": [ + - ], + - "name": "affectedCount", + + "name": "lt", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + } + }, + - "description": "Count of the records impacted by the mutation", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + }, + { + - "args": [ + - ], + - "name": "records", + + "name": "lte", + "type": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "LIST", + + "kind": "NON_NULL", + "name": null, + "ofType": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "OBJECT", + - "name": "Person", + - "ofType": null + - } + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + } + } + }, + - "description": "Array of records impacted by the mutation", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "neq", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "ov", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + } + ], + + "possibleTypes": null + + }, + + { + + "kind": "SCALAR", + + "name": "JSON", + + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": null, + + "description": "A Javascript Object Notation value serialized as a string", + "inputFields": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + - "name": "Query", + + "name": "Mutation", + "fields": [ + { + "args": [ + - { + - "name": "first", + - "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - }, + - "description": "Query the first `n` records in the collection", + - "defaultValue": null + - }, + - { + - "name": "last", + - "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - }, + - "description": "Query the last `n` records in the collection", + - "defaultValue": null + - }, + - { + - "name": "before", + - "type": { + - "kind": "SCALAR", + - "name": "Cursor", + - "ofType": null + - }, + - "description": "Query values in the collection before the provided cursor", + - "defaultValue": null + - }, + - { + - "name": "after", + - "type": { + - "kind": "SCALAR", + - "name": "Cursor", + - "ofType": null + - }, + - "description": "Query values in the collection after the provided cursor", + - "defaultValue": null + - }, + - { + - "name": "offset", + - "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - }, + - "description": "Skip n values from the after cursor. Alternative to cursor pagination. Backward pagination not supported.", + - "defaultValue": null + - }, + { + "name": "filter", + "type": { + @@ -5129,374 +4981,2270 @@ begin; "name": "AccountFilter", + "ofType": null + }, + - "description": "Filters to apply to the results set when querying from the collection", + + "description": "Restricts the mutation's impact to records matching the criteria", + "defaultValue": null + }, + { + - "name": "orderBy", + + "name": "atMost", + "type": { + - "kind": "LIST", + + "kind": "NON_NULL", + "name": null, + "ofType": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "AccountOrderBy", + - "ofType": null + - } + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + } + }, + - "description": "Sort order to apply to the collection", + - "defaultValue": null + + "description": "The maximum number of records in the collection permitted to be affected", + + "defaultValue": "1" + } + ], + - "name": "accountCollection", + + "name": "deleteFromAccountCollection", + "type": { + - "kind": "OBJECT", + - "name": "AccountConnection", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "AccountDeleteResponse", + + "ofType": null + + } + }, + - "description": "A pagable collection of type `Account`", + + "description": "Deletes zero or more records from the `Account` collection", + "isDeprecated": false, + "deprecationReason": null + }, + { + "args": [ + { + - "name": "first", + + "name": "filter", + "type": { + - "kind": "SCALAR", + - "name": "Int", + + "kind": "INPUT_OBJECT", + + "name": "BlogFilter", + "ofType": null + }, + - "description": "Query the first `n` records in the collection", + + "description": "Restricts the mutation's impact to records matching the criteria", + "defaultValue": null + }, + { + - "name": "last", + + "name": "atMost", + "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + }, + - "description": "Query the last `n` records in the collection", + - "defaultValue": null + - }, + + "description": "The maximum number of records in the collection permitted to be affected", + + "defaultValue": "1" + + } + + ], + + "name": "deleteFromBlogCollection", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "BlogDeleteResponse", + + "ofType": null + + } + + }, + + "description": "Deletes zero or more records from the `Blog` collection", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + { + - "name": "before", + + "name": "filter", + "type": { + - "kind": "SCALAR", + - "name": "Cursor", + + "kind": "INPUT_OBJECT", + + "name": "BlogPostFilter", + "ofType": null + }, + - "description": "Query values in the collection before the provided cursor", + + "description": "Restricts the mutation's impact to records matching the criteria", + "defaultValue": null + }, + { + - "name": "after", + + "name": "atMost", + "type": { + - "kind": "SCALAR", + - "name": "Cursor", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + }, + - "description": "Query values in the collection after the provided cursor", + - "defaultValue": null + - }, + + "description": "The maximum number of records in the collection permitted to be affected", + + "defaultValue": "1" + + } + + ], + + "name": "deleteFromBlogPostCollection", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "BlogPostDeleteResponse", + + "ofType": null + + } + + }, + + "description": "Deletes zero or more records from the `BlogPost` collection", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + { + - "name": "offset", + + "name": "filter", + "type": { + - "kind": "SCALAR", + - "name": "Int", + + "kind": "INPUT_OBJECT", + + "name": "PersonFilter", + "ofType": null + }, + - "description": "Skip n values from the after cursor. Alternative to cursor pagination. Backward pagination not supported.", + + "description": "Restricts the mutation's impact to records matching the criteria", + "defaultValue": null + }, + { + - "name": "filter", + + "name": "atMost", + "type": { + - "kind": "INPUT_OBJECT", + - "name": "BlogFilter", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + }, + - "description": "Filters to apply to the results set when querying from the collection", + - "defaultValue": null + - }, + + "description": "The maximum number of records in the collection permitted to be affected", + + "defaultValue": "1" + + } + + ], + + "name": "deleteFromPersonCollection", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "PersonDeleteResponse", + + "ofType": null + + } + + }, + + "description": "Deletes zero or more records from the `Person` collection", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + { + - "name": "orderBy", + + "name": "objects", + "type": { + - "kind": "LIST", + + "kind": "NON_NULL", + "name": null, + "ofType": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "BlogOrderBy", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "AccountInsertInput", + + "ofType": null + + } + } + } + }, + - "description": "Sort order to apply to the collection", + + "description": null, + "defaultValue": null + } + ], + - "name": "blogCollection", + + "name": "insertIntoAccountCollection", + "type": { + "kind": "OBJECT", + - "name": "BlogConnection", + + "name": "AccountInsertResponse", + "ofType": null + }, + - "description": "A pagable collection of type `Blog`", + + "description": "Adds one or more `Account` records to the collection", + "isDeprecated": false, + "deprecationReason": null + }, + { + "args": [ + { + - "name": "first", + - "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - }, + - "description": "Query the first `n` records in the collection", + - "defaultValue": null + - }, + - { + - "name": "last", + - "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - }, + - "description": "Query the last `n` records in the collection", + - "defaultValue": null + - }, + - { + - "name": "before", + - "type": { + - "kind": "SCALAR", + - "name": "Cursor", + - "ofType": null + - }, + - "description": "Query values in the collection before the provided cursor", + - "defaultValue": null + - }, + - { + - "name": "after", + - "type": { + - "kind": "SCALAR", + - "name": "Cursor", + - "ofType": null + - }, + - "description": "Query values in the collection after the provided cursor", + - "defaultValue": null + - }, + - { + - "name": "offset", + - "type": { + - "kind": "SCALAR", + - "name": "Int", + - "ofType": null + - }, + - "description": "Skip n values from the after cursor. Alternative to cursor pagination. Backward pagination not supported.", + - "defaultValue": null + - }, + - { + - "name": "filter", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "BlogPostFilter", + - "ofType": null + - }, + - "description": "Filters to apply to the results set when querying from the collection", + - "defaultValue": null + - }, + - { + - "name": "orderBy", + + "name": "objects", + "type": { + - "kind": "LIST", + + "kind": "NON_NULL", + "name": null, + "ofType": { + - "kind": "NON_NULL", + + "kind": "LIST", + "name": null, + "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "BlogPostOrderBy", + - "ofType": null + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "BlogInsertInput", + + "ofType": null + + } + } + } + }, + - "description": "Sort order to apply to the collection", + + "description": null, + "defaultValue": null + } + ], + - "name": "blogPostCollection", + + "name": "insertIntoBlogCollection", + "type": { + "kind": "OBJECT", + - "name": "BlogPostConnection", + + "name": "BlogInsertResponse", + "ofType": null + }, + - "description": "A pagable collection of type `BlogPost`", + + "description": "Adds one or more `Blog` records to the collection", + "isDeprecated": false, + "deprecationReason": null + }, + { + "args": [ + { + - "name": "nodeId", + + "name": "objects", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + - "kind": "SCALAR", + - "name": "ID", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "BlogPostInsertInput", + + "ofType": null + + } + + } + } + }, + - "description": "The record's `ID`", + + "description": null, + "defaultValue": null + } + ], + - "name": "node", + + "name": "insertIntoBlogPostCollection", + "type": { + - "kind": "INTERFACE", + - "name": "Node", + + "kind": "OBJECT", + + "name": "BlogPostInsertResponse", + "ofType": null + }, + - "description": "Retrieve a record by its `ID`", + + "description": "Adds one or more `BlogPost` records to the collection", + "isDeprecated": false, + "deprecationReason": null + }, + { + "args": [ + { + - "name": "first", + + "name": "objects", + "type": { + - "kind": "SCALAR", + - "name": "Int", + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "PersonInsertInput", + + "ofType": null + + } + + } + + } + + }, + + "description": null, + + "defaultValue": null + + } + + ], + + "name": "insertIntoPersonCollection", + + "type": { + + "kind": "OBJECT", + + "name": "PersonInsertResponse", + + "ofType": null + + }, + + "description": "Adds one or more `Person` records to the collection", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + { + + "name": "set", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "AccountUpdateInput", + + "ofType": null + + } + + }, + + "description": "Fields that are set will be updated for all records matching the `filter`", + + "defaultValue": null + + }, + + { + + "name": "filter", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "AccountFilter", + "ofType": null + }, + - "description": "Query the first `n` records in the collection", + + "description": "Restricts the mutation's impact to records matching the criteria", + "defaultValue": null + }, + { + - "name": "last", + + "name": "atMost", + "type": { + - "kind": "SCALAR", + - "name": "Int", + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + }, + + "description": "The maximum number of records in the collection permitted to be affected", + + "defaultValue": "1" + + } + + ], + + "name": "updateAccountCollection", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "AccountUpdateResponse", + + "ofType": null + + } + + }, + + "description": "Updates zero or more records in the `Account` collection", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + { + + "name": "set", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "BlogUpdateInput", + + "ofType": null + + } + + }, + + "description": "Fields that are set will be updated for all records matching the `filter`", + + "defaultValue": null + + }, + + { + + "name": "filter", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "BlogFilter", + "ofType": null + }, + - "description": "Query the last `n` records in the collection", + + "description": "Restricts the mutation's impact to records matching the criteria", + "defaultValue": null + }, + { + - "name": "before", + + "name": "atMost", + "type": { + - "kind": "SCALAR", + - "name": "Cursor", + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + }, + + "description": "The maximum number of records in the collection permitted to be affected", + + "defaultValue": "1" + + } + + ], + + "name": "updateBlogCollection", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "BlogUpdateResponse", + + "ofType": null + + } + + }, + + "description": "Updates zero or more records in the `Blog` collection", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + { + + "name": "set", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "BlogPostUpdateInput", + + "ofType": null + + } + + }, + + "description": "Fields that are set will be updated for all records matching the `filter`", + + "defaultValue": null + + }, + + { + + "name": "filter", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "BlogPostFilter", + "ofType": null + }, + - "description": "Query values in the collection before the provided cursor", + + "description": "Restricts the mutation's impact to records matching the criteria", + "defaultValue": null + }, + { + - "name": "after", + + "name": "atMost", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + }, + + "description": "The maximum number of records in the collection permitted to be affected", + + "defaultValue": "1" + + } + + ], + + "name": "updateBlogPostCollection", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "BlogPostUpdateResponse", + + "ofType": null + + } + + }, + + "description": "Updates zero or more records in the `BlogPost` collection", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + { + + "name": "set", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "PersonUpdateInput", + + "ofType": null + + } + + }, + + "description": "Fields that are set will be updated for all records matching the `filter`", + + "defaultValue": null + + }, + + { + + "name": "filter", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "PersonFilter", + + "ofType": null + + }, + + "description": "Restricts the mutation's impact to records matching the criteria", + + "defaultValue": null + + }, + + { + + "name": "atMost", + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + }, + + "description": "The maximum number of records in the collection permitted to be affected", + + "defaultValue": "1" + + } + + ], + + "name": "updatePersonCollection", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "PersonUpdateResponse", + + "ofType": null + + } + + }, + + "description": "Updates zero or more records in the `Person` collection", + + "isDeprecated": false, + + "deprecationReason": null + + } + + ], + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "The root type for creating and mutating data", + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "INTERFACE", + + "name": "Node", + + "fields": [ + + { + + "args": [ + + ], + + "name": "nodeId", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + + } + + }, + + "description": "Retrieves a record by `ID`", + + "isDeprecated": false, + + "deprecationReason": null + + } + + ], + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": null, + + "inputFields": null, + + "possibleTypes": [ + + { + + "kind": "OBJECT", + + "name": "Account", + + "ofType": null + + }, + + { + + "kind": "OBJECT", + + "name": "Blog", + + "ofType": null + + }, + + { + + "kind": "OBJECT", + + "name": "BlogPost", + + "ofType": null + + }, + + { + + "kind": "OBJECT", + + "name": "Person", + + "ofType": null + + } + + ] + + }, + + { + + "kind": "SCALAR", + + "name": "Opaque", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "Any type not handled by the type system", + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "OpaqueFilter", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "Boolean expression comparing fields on type \"Opaque\"", + + "inputFields": [ + + { + + "name": "eq", + + "type": { + + "kind": "SCALAR", + + "name": "Opaque", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "is", + + "type": { + + "kind": "ENUM", + + "name": "FilterIs", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + } + + ], + + "possibleTypes": null + + }, + + { + + "kind": "ENUM", + + "name": "OrderByDirection", + + "fields": null, + + "enumValues": [ + + { + + "name": "AscNullsFirst", + + "description": "Ascending order, nulls first", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "name": "AscNullsLast", + + "description": "Ascending order, nulls last", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "name": "DescNullsFirst", + + "description": "Descending order, nulls first", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "name": "DescNullsLast", + + "description": "Descending order, nulls last", + + "isDeprecated": false, + + "deprecationReason": null + + } + + ], + + "interfaces": [ + + ], + + "description": "Defines a per-field sorting order", + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "OBJECT", + + "name": "PageInfo", + + "fields": [ + + { + + "args": [ + + ], + + "name": "endCursor", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "hasNextPage", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Boolean", + + "ofType": null + + } + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "hasPreviousPage", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Boolean", + + "ofType": null + + } + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "startCursor", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + } + + ], + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": null, + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "OBJECT", + + "name": "Person", + + "fields": [ + + { + + "args": [ + + ], + + "name": "nodeId", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + + } + + }, + + "description": "Globally Unique Record Identifier", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "id", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "email", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "encryptedPassword", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "createdAt", + + "type": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "updatedAt", + + "type": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + { + + "name": "first", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Query the first `n` records in the collection", + + "defaultValue": null + + }, + + { + + "name": "last", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Query the last `n` records in the collection", + + "defaultValue": null + + }, + + { + + "name": "before", + + "type": { + + "kind": "SCALAR", + + "name": "Cursor", + + "ofType": null + + }, + + "description": "Query values in the collection before the provided cursor", + + "defaultValue": null + + }, + + { + + "name": "after", + + "type": { + + "kind": "SCALAR", + + "name": "Cursor", + + "ofType": null + + }, + + "description": "Query values in the collection after the provided cursor", + + "defaultValue": null + + }, + + { + + "name": "offset", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Skip n values from the after cursor. Alternative to cursor pagination. Backward pagination not supported.", + + "defaultValue": null + + }, + + { + + "name": "filter", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "BlogFilter", + + "ofType": null + + }, + + "description": "Filters to apply to the results set when querying from the collection", + + "defaultValue": null + + }, + + { + + "name": "orderBy", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "BlogOrderBy", + + "ofType": null + + } + + } + + }, + + "description": "Sort order to apply to the collection", + + "defaultValue": null + + } + + ], + + "name": "blogs", + + "type": { + + "kind": "OBJECT", + + "name": "BlogConnection", + + "ofType": null + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + } + + ], + + "enumValues": [ + + ], + + "interfaces": [ + + { + + "kind": "INTERFACE", + + "name": "Node", + + "ofType": null + + } + + ], + + "description": null, + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "OBJECT", + + "name": "PersonConnection", + + "fields": [ + + { + + "args": [ + + ], + + "name": "edges", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "PersonEdge", + + "ofType": null + + } + + } + + } + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "pageInfo", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "PageInfo", + + "ofType": null + + } + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + } + + ], + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": null, + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "OBJECT", + + "name": "PersonDeleteResponse", + + "fields": [ + + { + + "args": [ + + ], + + "name": "affectedCount", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + }, + + "description": "Count of the records impacted by the mutation", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "records", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "Person", + + "ofType": null + + } + + } + + } + + }, + + "description": "Array of records impacted by the mutation", + + "isDeprecated": false, + + "deprecationReason": null + + } + + ], + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": null, + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "OBJECT", + + "name": "PersonEdge", + + "fields": [ + + { + + "args": [ + + ], + + "name": "cursor", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + } + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "node", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "Person", + + "ofType": null + + } + + }, + + "description": null, + + "isDeprecated": false, + + "deprecationReason": null + + } + + ], + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": null, + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "PersonFilter", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": null, + + "inputFields": [ + + { + + "name": "id", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "IntFilter", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "email", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "StringFilter", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "encryptedPassword", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "StringFilter", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "createdAt", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "DatetimeFilter", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "updatedAt", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "DatetimeFilter", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "nodeId", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "IDFilter", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "and", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "PersonFilter", + + "ofType": null + + } + + } + + }, + + "description": "Returns true only if all its inner filters are true, otherwise returns false", + + "defaultValue": null + + }, + + { + + "name": "or", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "PersonFilter", + + "ofType": null + + } + + } + + }, + + "description": "Returns true if at least one of its inner filters is true, otherwise returns false", + + "defaultValue": null + + }, + + { + + "name": "not", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "PersonFilter", + + "ofType": null + + }, + + "description": "Negates a filter", + + "defaultValue": null + + } + + ], + + "possibleTypes": null + + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "PersonInsertInput", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": null, + + "inputFields": [ + + { + + "name": "id", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "email", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "encryptedPassword", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "createdAt", + + "type": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "updatedAt", + + "type": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + } + + ], + + "possibleTypes": null + + }, + + { + + "kind": "OBJECT", + + "name": "PersonInsertResponse", + + "fields": [ + + { + + "args": [ + + ], + + "name": "affectedCount", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + }, + + "description": "Count of the records impacted by the mutation", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "records", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "Person", + + "ofType": null + + } + + } + + } + + }, + + "description": "Array of records impacted by the mutation", + + "isDeprecated": false, + + "deprecationReason": null + + } + + ], + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": null, + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "PersonOrderBy", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": null, + + "inputFields": [ + + { + + "name": "id", + + "type": { + + "kind": "ENUM", + + "name": "OrderByDirection", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "email", + + "type": { + + "kind": "ENUM", + + "name": "OrderByDirection", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "encryptedPassword", + + "type": { + + "kind": "ENUM", + + "name": "OrderByDirection", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "createdAt", + + "type": { + + "kind": "ENUM", + + "name": "OrderByDirection", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "updatedAt", + + "type": { + + "kind": "ENUM", + + "name": "OrderByDirection", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + } + + ], + + "possibleTypes": null + + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "PersonUpdateInput", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": null, + + "inputFields": [ + + { + + "name": "id", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "email", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "encryptedPassword", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "createdAt", + + "type": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "updatedAt", + + "type": { + + "kind": "SCALAR", + + "name": "Datetime", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + } + + ], + + "possibleTypes": null + + }, + + { + + "kind": "OBJECT", + + "name": "PersonUpdateResponse", + + "fields": [ + + { + + "args": [ + + ], + + "name": "affectedCount", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + } + + }, + + "description": "Count of the records impacted by the mutation", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + ], + + "name": "records", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "OBJECT", + + "name": "Person", + + "ofType": null + + } + + } + + } + + }, + + "description": "Array of records impacted by the mutation", + + "isDeprecated": false, + + "deprecationReason": null + + } + + ], + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": null, + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "OBJECT", + + "name": "Query", + + "fields": [ + + { + + "args": [ + + { + + "name": "first", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Query the first `n` records in the collection", + + "defaultValue": null + + }, + + { + + "name": "last", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Query the last `n` records in the collection", + + "defaultValue": null + + }, + + { + + "name": "before", + + "type": { + + "kind": "SCALAR", + + "name": "Cursor", + + "ofType": null + + }, + + "description": "Query values in the collection before the provided cursor", + + "defaultValue": null + + }, + + { + + "name": "after", + + "type": { + + "kind": "SCALAR", + + "name": "Cursor", + + "ofType": null + + }, + + "description": "Query values in the collection after the provided cursor", + + "defaultValue": null + + }, + + { + + "name": "offset", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Skip n values from the after cursor. Alternative to cursor pagination. Backward pagination not supported.", + + "defaultValue": null + + }, + + { + + "name": "filter", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "AccountFilter", + + "ofType": null + + }, + + "description": "Filters to apply to the results set when querying from the collection", + + "defaultValue": null + + }, + + { + + "name": "orderBy", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "AccountOrderBy", + + "ofType": null + + } + + } + + }, + + "description": "Sort order to apply to the collection", + + "defaultValue": null + + } + + ], + + "name": "accountCollection", + + "type": { + + "kind": "OBJECT", + + "name": "AccountConnection", + + "ofType": null + + }, + + "description": "A pagable collection of type `Account`", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + { + + "name": "first", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Query the first `n` records in the collection", + + "defaultValue": null + + }, + + { + + "name": "last", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Query the last `n` records in the collection", + + "defaultValue": null + + }, + + { + + "name": "before", + + "type": { + + "kind": "SCALAR", + + "name": "Cursor", + + "ofType": null + + }, + + "description": "Query values in the collection before the provided cursor", + + "defaultValue": null + + }, + + { + + "name": "after", + + "type": { + + "kind": "SCALAR", + + "name": "Cursor", + + "ofType": null + + }, + + "description": "Query values in the collection after the provided cursor", + + "defaultValue": null + + }, + + { + + "name": "offset", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Skip n values from the after cursor. Alternative to cursor pagination. Backward pagination not supported.", + + "defaultValue": null + + }, + + { + + "name": "filter", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "BlogFilter", + + "ofType": null + + }, + + "description": "Filters to apply to the results set when querying from the collection", + + "defaultValue": null + + }, + + { + + "name": "orderBy", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "BlogOrderBy", + + "ofType": null + + } + + } + + }, + + "description": "Sort order to apply to the collection", + + "defaultValue": null + + } + + ], + + "name": "blogCollection", + + "type": { + + "kind": "OBJECT", + + "name": "BlogConnection", + + "ofType": null + + }, + + "description": "A pagable collection of type `Blog`", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + { + + "name": "first", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Query the first `n` records in the collection", + + "defaultValue": null + + }, + + { + + "name": "last", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Query the last `n` records in the collection", + + "defaultValue": null + + }, + + { + + "name": "before", + + "type": { + + "kind": "SCALAR", + + "name": "Cursor", + + "ofType": null + + }, + + "description": "Query values in the collection before the provided cursor", + + "defaultValue": null + + }, + + { + + "name": "after", + + "type": { + + "kind": "SCALAR", + + "name": "Cursor", + + "ofType": null + + }, + + "description": "Query values in the collection after the provided cursor", + + "defaultValue": null + + }, + + { + + "name": "offset", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Skip n values from the after cursor. Alternative to cursor pagination. Backward pagination not supported.", + + "defaultValue": null + + }, + + { + + "name": "filter", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "BlogPostFilter", + + "ofType": null + + }, + + "description": "Filters to apply to the results set when querying from the collection", + + "defaultValue": null + + }, + + { + + "name": "orderBy", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "BlogPostOrderBy", + + "ofType": null + + } + + } + + }, + + "description": "Sort order to apply to the collection", + + "defaultValue": null + + } + + ], + + "name": "blogPostCollection", + + "type": { + + "kind": "OBJECT", + + "name": "BlogPostConnection", + + "ofType": null + + }, + + "description": "A pagable collection of type `BlogPost`", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + { + + "name": "nodeId", + + "type": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "ID", + + "ofType": null + + } + + }, + + "description": "The record's `ID`", + + "defaultValue": null + + } + + ], + + "name": "node", + + "type": { + + "kind": "INTERFACE", + + "name": "Node", + + "ofType": null + + }, + + "description": "Retrieve a record by its `ID`", + + "isDeprecated": false, + + "deprecationReason": null + + }, + + { + + "args": [ + + { + + "name": "first", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Query the first `n` records in the collection", + + "defaultValue": null + + }, + + { + + "name": "last", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Query the last `n` records in the collection", + + "defaultValue": null + + }, + + { + + "name": "before", + + "type": { + + "kind": "SCALAR", + + "name": "Cursor", + + "ofType": null + + }, + + "description": "Query values in the collection before the provided cursor", + + "defaultValue": null + + }, + + { + + "name": "after", + + "type": { + + "kind": "SCALAR", + + "name": "Cursor", + + "ofType": null + + }, + + "description": "Query values in the collection after the provided cursor", + + "defaultValue": null + + }, + + { + + "name": "offset", + + "type": { + + "kind": "SCALAR", + + "name": "Int", + + "ofType": null + + }, + + "description": "Skip n values from the after cursor. Alternative to cursor pagination. Backward pagination not supported.", + + "defaultValue": null + + }, + + { + + "name": "filter", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "PersonFilter", + + "ofType": null + + }, + + "description": "Filters to apply to the results set when querying from the collection", + + "defaultValue": null + + }, + + { + + "name": "orderBy", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "INPUT_OBJECT", + + "name": "PersonOrderBy", + + "ofType": null + + } + + } + + }, + + "description": "Sort order to apply to the collection", + + "defaultValue": null + + } + + ], + + "name": "personCollection", + + "type": { + + "kind": "OBJECT", + + "name": "PersonConnection", + + "ofType": null + + }, + + "description": "A pagable collection of type `Person`", + + "isDeprecated": false, + + "deprecationReason": null + + } + + ], + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "The root type for querying data", + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "SCALAR", + + "name": "String", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "A string", + + "inputFields": null, + + "possibleTypes": null + + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "StringFilter", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "Boolean expression comparing fields on type \"String\"", + + "inputFields": [ + + { + + "name": "eq", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "gt", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "gte", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "ilike", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "in", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "iregex", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "is", + + "type": { + + "kind": "ENUM", + + "name": "FilterIs", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "like", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "lt", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "lte", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "neq", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "regex", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "startsWith", + + "type": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + } + + ], + + "possibleTypes": null + + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "StringListFilter", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "Boolean expression comparing fields on type \"StringList\"", + + "inputFields": [ + + { + + "name": "cd", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "cs", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "eq", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "gt", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "gte", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "lt", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + "kind": "SCALAR", + - "name": "Cursor", + + "name": "String", + "ofType": null + - }, + - "description": "Query values in the collection after the provided cursor", + - "defaultValue": null + - }, + - { + - "name": "offset", + - "type": { + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "lte", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + "kind": "SCALAR", + - "name": "Int", + + "name": "String", + "ofType": null + - }, + - "description": "Skip n values from the after cursor. Alternative to cursor pagination. Backward pagination not supported.", + - "defaultValue": null + - }, + - { + - "name": "filter", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "PersonFilter", + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "neq", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "String", + "ofType": null + - }, + - "description": "Filters to apply to the results set when querying from the collection", + - "defaultValue": null + - }, + - { + - "name": "orderBy", + - "type": { + - "kind": "LIST", + - "name": null, + - "ofType": { + - "kind": "NON_NULL", + - "name": null, + - "ofType": { + - "kind": "INPUT_OBJECT", + - "name": "PersonOrderBy", + - "ofType": null + - } + - } + - }, + - "description": "Sort order to apply to the collection", + - "defaultValue": null + + } + } + - ], + - "name": "personCollection", + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "ov", + "type": { + - "kind": "OBJECT", + - "name": "PersonConnection", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "String", + + "ofType": null + + } + + } + }, + - "description": "A pagable collection of type `Person`", + - "isDeprecated": false, + - "deprecationReason": null + + "description": null, + + "defaultValue": null + } + ], + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": "The root type for querying data", + - "inputFields": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + - "name": "String", + + "name": "Time", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "A string", + + "description": "A time without date information", + "inputFields": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + - "name": "StringFilter", + + "name": "TimeFilter", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "Boolean expression comparing fields on type \"String\"", + + "description": "Boolean expression comparing fields on type \"Time\"", + "inputFields": [ + { + "name": "eq", + "type": { + "kind": "SCALAR", + - "name": "String", + + "name": "Time", + "ofType": null + }, + "description": null, + @@ -5506,7 +7254,7 @@ begin; "name": "gt", + "type": { + "kind": "SCALAR", + - "name": "String", + + "name": "Time", + "ofType": null + }, + "description": null, + @@ -5516,24 +7264,85 @@ begin; "name": "gte", + "type": { + "kind": "SCALAR", + - "name": "String", + + "name": "Time", + "ofType": null + }, + "description": null, + "defaultValue": null + }, + { + - "name": "ilike", + + "name": "in", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Time", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "is", + + "type": { + + "kind": "ENUM", + + "name": "FilterIs", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "lt", + "type": { + "kind": "SCALAR", + - "name": "String", + + "name": "Time", + "ofType": null + }, + "description": null, + "defaultValue": null + }, + { + - "name": "in", + + "name": "lte", + + "type": { + + "kind": "SCALAR", + + "name": "Time", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "neq", + + "type": { + + "kind": "SCALAR", + + "name": "Time", + + "ofType": null + + }, + + "description": null, + + "defaultValue": null + + } + + ], + + "possibleTypes": null + + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "TimeListFilter", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "Boolean expression comparing fields on type \"TimeList\"", + + "inputFields": [ + + { + + "name": "cd", + "type": { + "kind": "LIST", + "name": null, + @@ -5542,7 +7351,7 @@ begin; "name": null, + "ofType": { + "kind": "SCALAR", + - "name": "String", + + "name": "Time", + "ofType": null + } + } + @@ -5551,81 +7360,145 @@ begin; "defaultValue": null + }, + { + - "name": "iregex", + + "name": "cs", + "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Time", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "is", + + "name": "eq", + "type": { + - "kind": "ENUM", + - "name": "FilterIs", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Time", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "like", + + "name": "gt", + "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Time", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "lt", + + "name": "gte", + "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Time", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "lte", + + "name": "lt", + "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Time", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "neq", + + "name": "lte", + "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Time", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "regex", + + "name": "neq", + "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Time", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "startsWith", + + "name": "ov", + "type": { + - "kind": "SCALAR", + - "name": "String", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "Time", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + @@ -5635,58 +7508,89 @@ begin; }, + { + "kind": "SCALAR", + - "name": "Time", + + "name": "UUID", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "A time without date information", + + "description": "A universally unique identifier", + "inputFields": null, + "possibleTypes": null + }, + { + "kind": "INPUT_OBJECT", + - "name": "TimeFilter", + + "name": "UUIDFilter", + "fields": null, + "enumValues": [ + ], + "interfaces": [ + ], + - "description": "Boolean expression comparing fields on type \"Time\"", + + "description": "Boolean expression comparing fields on type \"UUID\"", + "inputFields": [ + { + "name": "eq", + "type": { + "kind": "SCALAR", + - "name": "Time", + + "name": "UUID", + "ofType": null + }, + "description": null, + "defaultValue": null + }, + { + - "name": "gt", + + "name": "in", + "type": { + - "kind": "SCALAR", + - "name": "Time", + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "UUID", + + "ofType": null + + } + + } + + }, + + "description": null, + + "defaultValue": null + + }, + + { + + "name": "is", + + "type": { + + "kind": "ENUM", + + "name": "FilterIs", + "ofType": null + }, + "description": null, + "defaultValue": null + }, + { + - "name": "gte", + + "name": "neq", + "type": { + "kind": "SCALAR", + - "name": "Time", + + "name": "UUID", + "ofType": null + }, + "description": null, + "defaultValue": null + - }, + + } + + ], + + "possibleTypes": null + + }, + + { + + "kind": "INPUT_OBJECT", + + "name": "UUIDListFilter", + + "fields": null, + + "enumValues": [ + + ], + + "interfaces": [ + + ], + + "description": "Boolean expression comparing fields on type \"UUIDList\"", + + "inputFields": [ + { + - "name": "in", + + "name": "cd", + "type": { + "kind": "LIST", + "name": null, + @@ -5695,7 +7599,7 @@ begin; "name": null, + "ofType": { + "kind": "SCALAR", + - "name": "Time", + + "name": "UUID", + "ofType": null + } + } + @@ -5704,82 +7608,97 @@ begin; "defaultValue": null + }, + { + - "name": "is", + + "name": "cs", + "type": { + - "kind": "ENUM", + - "name": "FilterIs", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "UUID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "lt", + + "name": "eq", + "type": { + - "kind": "SCALAR", + - "name": "Time", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "UUID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "lte", + + "name": "gt", + "type": { + - "kind": "SCALAR", + - "name": "Time", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "UUID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "neq", + + "name": "gte", + "type": { + - "kind": "SCALAR", + - "name": "Time", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "UUID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + - } + - ], + - "possibleTypes": null + - }, + - { + - "kind": "SCALAR", + - "name": "UUID", + - "fields": null, + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": "A universally unique identifier", + - "inputFields": null, + - "possibleTypes": null + - }, + - { + - "kind": "INPUT_OBJECT", + - "name": "UUIDFilter", + - "fields": null, + - "enumValues": [ + - ], + - "interfaces": [ + - ], + - "description": "Boolean expression comparing fields on type \"UUID\"", + - "inputFields": [ + + }, + { + - "name": "eq", + + "name": "lt", + "type": { + - "kind": "SCALAR", + - "name": "UUID", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "UUID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "in", + + "name": "lte", + "type": { + "kind": "LIST", + "name": null, + @@ -5797,21 +7716,37 @@ begin; "defaultValue": null + }, + { + - "name": "is", + + "name": "neq", + "type": { + - "kind": "ENUM", + - "name": "FilterIs", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "UUID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + }, + { + - "name": "neq", + + "name": "ov", + "type": { + - "kind": "SCALAR", + - "name": "UUID", + - "ofType": null + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null, + + "ofType": { + + "kind": "SCALAR", + + "name": "UUID", + + "ofType": null + + } + + } + }, + "description": null, + "defaultValue": null + diff --git a/test/expected/roundtrip_types.out b/test/expected/roundtrip_types.out index a033a219..4e5bbd76 100644 --- a/test/expected/roundtrip_types.out +++ b/test/expected/roundtrip_types.out @@ -566,166 +566,198 @@ begin; } $$) ); - jsonb_pretty ---------------------------------------------------- - { + - "data": { + - "__type": { + - "kind": "INPUT_OBJECT", + - "inputFields": [ + - { + - "name": "id", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "IntFilter", + - "ofType": null + - } + - }, + - { + - "name": "typeBigint", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "BigIntFilter", + - "ofType": null + - } + - }, + - { + - "name": "typeText", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "StringFilter", + - "ofType": null + - } + - }, + - { + - "name": "typeVarchar", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "StringFilter", + - "ofType": null + - } + - }, + - { + - "name": "typeVarchar_n", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "StringFilter", + - "ofType": null + - } + - }, + - { + - "name": "typeChar", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "StringFilter", + - "ofType": null + - } + - }, + - { + - "name": "typeUuid", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "UUIDFilter", + - "ofType": null + - } + - }, + - { + - "name": "typeDate", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "DateFilter", + - "ofType": null + - } + - }, + - { + - "name": "typeTime", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "TimeFilter", + - "ofType": null + - } + - }, + - { + - "name": "typeDatetime", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "DatetimeFilter",+ - "ofType": null + - } + - }, + - { + - "name": "typeEnum", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "ColorFilter", + - "ofType": null + - } + - }, + - { + - "name": "typeNumeric", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "BigFloatFilter",+ - "ofType": null + - } + - }, + - { + - "name": "typeFloat", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "FloatFilter", + - "ofType": null + - } + - }, + - { + - "name": "typeDouble", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "FloatFilter", + - "ofType": null + - } + - }, + - { + - "name": "nodeId", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "IDFilter", + - "ofType": null + - } + - }, + - { + - "name": "and", + - "type": { + - "kind": "LIST", + - "name": null, + - "ofType": { + - "kind": "NON_NULL", + - "name": null + - } + - } + - }, + - { + - "name": "or", + - "type": { + - "kind": "LIST", + - "name": null, + - "ofType": { + - "kind": "NON_NULL", + - "name": null + - } + - } + - }, + - { + - "name": "not", + - "type": { + - "kind": "INPUT_OBJECT", + - "name": "MainTypeFilter",+ - "ofType": null + - } + - } + - ] + - } + - } + + jsonb_pretty +------------------------------------------------------- + { + + "data": { + + "__type": { + + "kind": "INPUT_OBJECT", + + "inputFields": [ + + { + + "name": "id", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "IntFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeBigint", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "BigIntFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeText", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "StringFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeVarchar", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "StringFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeVarchar_n", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "StringFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeChar", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "StringFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeUuid", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "UUIDFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeDate", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "DateFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeTime", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "TimeFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeDatetime", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "DatetimeFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeEnum", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "ColorFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeNumeric", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "BigFloatFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeFloat", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "FloatFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeDouble", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "FloatFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeArrayEnum", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "ColorListFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeArrayText", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "StringListFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeArrayJson", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "JSONListFilter", + + "ofType": null + + } + + }, + + { + + "name": "typeArrayNumeric", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "BigFloatListFilter",+ + "ofType": null + + } + + }, + + { + + "name": "nodeId", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "IDFilter", + + "ofType": null + + } + + }, + + { + + "name": "and", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null + + } + + } + + }, + + { + + "name": "or", + + "type": { + + "kind": "LIST", + + "name": null, + + "ofType": { + + "kind": "NON_NULL", + + "name": null + + } + + } + + }, + + { + + "name": "not", + + "type": { + + "kind": "INPUT_OBJECT", + + "name": "MainTypeFilter", + + "ofType": null + + } + + } + + ] + + } + + } + } (1 row) diff --git a/test/sql/omit_exotic_types.sql b/test/sql/omit_exotic_types.sql index 3f39e48c..cf081afe 100644 --- a/test/sql/omit_exotic_types.sql +++ b/test/sql/omit_exotic_types.sql @@ -1,9 +1,8 @@ begin; /* - Composite and array types are not currently supported as inputs + Composite types are not currently supported as inputs - confirm composites are not allowed anywhere - - confirm arrays are not allowed as input */ create type complex as (r int, i int); From 384e394243fac7a32cee89af0f515c10e1e3c77e Mon Sep 17 00:00:00 2001 From: Mora Date: Wed, 15 May 2024 22:56:43 -0700 Subject: [PATCH 17/29] adding test cases for filtering by array columns --- test/expected/resolve_connection_filter.out | 186 +++++++++++++++++++- test/sql/resolve_connection_filter.sql | 91 +++++++++- 2 files changed, 267 insertions(+), 10 deletions(-) diff --git a/test/expected/resolve_connection_filter.out b/test/expected/resolve_connection_filter.out index 8a7bdc6d..a6795686 100644 --- a/test/expected/resolve_connection_filter.out +++ b/test/expected/resolve_connection_filter.out @@ -3,13 +3,14 @@ begin; id int primary key, is_verified bool, name text, - phone text + phone text, + tags text[] ); - insert into public.account(id, is_verified, name, phone) + insert into public.account(id, is_verified, name, phone, tags) values - (1, true, 'foo', '1111111111'), - (2, true, 'bar', null), - (3, false, 'baz', '33333333333'); + (1, true, 'foo', '1111111111', '{"customer", "priority"}'), + (2, true, 'bar', null, '{"customer"}'), + (3, false, 'baz', '33333333333', '{"lead", "priority"}'); savepoint a; -- Filter by Int select jsonb_pretty( @@ -230,6 +231,181 @@ begin; {"data": null, "errors": [{"message": "Error transpiling Is filter value type"}]} (1 row) + rollback to savepoint a; + -- cs - array column contains the input scalar + select jsonb_pretty( + graphql.resolve($$ + { + accountCollection(filter: {tags: {cs: "customer"}}) { + edges { + node { + id + } + } + } + } + $$) + ); + jsonb_pretty +--------------------------------- + { + + "data": { + + "accountCollection": { + + "edges": [ + + { + + "node": { + + "id": 1+ + } + + }, + + { + + "node": { + + "id": 2+ + } + + } + + ] + + } + + } + + } +(1 row) + + rollback to savepoint a; + -- cd - array column is contained by input scalar (aka, the only value in the array column is the input scalar) + select jsonb_pretty( + graphql.resolve($$ + { + accountCollection(filter: {tags: {cd: "customer"}}) { + edges { + node { + id + } + } + } + } + $$) + ); + jsonb_pretty +--------------------------------- + { + + "data": { + + "accountCollection": { + + "edges": [ + + { + + "node": { + + "id": 2+ + } + + } + + ] + + } + + } + + } +(1 row) + + rollback to savepoint a; + -- cs - array column contains the input array + select jsonb_pretty( + graphql.resolve($$ + { + accountCollection(filter: {tags: {cs: ["customer", "priority"]}}) { + edges { + node { + id + } + } + } + } + $$) + ); + jsonb_pretty +--------------------------------- + { + + "data": { + + "accountCollection": { + + "edges": [ + + { + + "node": { + + "id": 1+ + } + + } + + ] + + } + + } + + } +(1 row) + + rollback to savepoint a; + -- cd - array column is contained by input array + select jsonb_pretty( + graphql.resolve($$ + { + accountCollection(filter: {tags: {cd: ["customer", "priority"]}}) { + edges { + node { + id + } + } + } + } + $$) + ); + jsonb_pretty +--------------------------------- + { + + "data": { + + "accountCollection": { + + "edges": [ + + { + + "node": { + + "id": 1+ + } + + }, + + { + + "node": { + + "id": 2+ + } + + } + + ] + + } + + } + + } +(1 row) + + rollback to savepoint a; + -- ov - array column overlaps with input array + select jsonb_pretty( + graphql.resolve($$ + { + accountCollection(filter: {tags: {cd: ["customer", "priority"]}}) { + edges { + node { + id + } + } + } + } + $$) + ); + jsonb_pretty +--------------------------------- + { + + "data": { + + "accountCollection": { + + "edges": [ + + { + + "node": { + + "id": 1+ + } + + }, + + { + + "node": { + + "id": 2+ + } + + } + + ] + + } + + } + + } +(1 row) + rollback to savepoint a; -- variable is - is null select graphql.resolve($$query AAA($nis: FilterIs) { accountCollection(filter: {phone: {is: $nis}}) { edges { node { id } } }}$$, '{"nis": "NULL"}'); diff --git a/test/sql/resolve_connection_filter.sql b/test/sql/resolve_connection_filter.sql index f2dcc85f..cfa8b772 100644 --- a/test/sql/resolve_connection_filter.sql +++ b/test/sql/resolve_connection_filter.sql @@ -3,14 +3,15 @@ begin; id int primary key, is_verified bool, name text, - phone text + phone text, + tags text[] ); - insert into public.account(id, is_verified, name, phone) + insert into public.account(id, is_verified, name, phone, tags) values - (1, true, 'foo', '1111111111'), - (2, true, 'bar', null), - (3, false, 'baz', '33333333333'); + (1, true, 'foo', '1111111111', '{"customer", "priority"}'), + (2, true, 'bar', null, '{"customer"}'), + (3, false, 'baz', '33333333333', '{"lead", "priority"}'); savepoint a; @@ -121,6 +122,86 @@ begin; select graphql.resolve($${accountCollection(filter: {phone: {is: null}}) { edges { node { id } } }}$$); rollback to savepoint a; + -- cs - array column contains the input scalar + select jsonb_pretty( + graphql.resolve($$ + { + accountCollection(filter: {tags: {cs: "customer"}}) { + edges { + node { + id + } + } + } + } + $$) + ); + rollback to savepoint a; + + -- cd - array column is contained by input scalar (aka, the only value in the array column is the input scalar) + select jsonb_pretty( + graphql.resolve($$ + { + accountCollection(filter: {tags: {cd: "customer"}}) { + edges { + node { + id + } + } + } + } + $$) + ); + rollback to savepoint a; + + -- cs - array column contains the input array + select jsonb_pretty( + graphql.resolve($$ + { + accountCollection(filter: {tags: {cs: ["customer", "priority"]}}) { + edges { + node { + id + } + } + } + } + $$) + ); + rollback to savepoint a; + + -- cd - array column is contained by input array + select jsonb_pretty( + graphql.resolve($$ + { + accountCollection(filter: {tags: {cd: ["customer", "priority"]}}) { + edges { + node { + id + } + } + } + } + $$) + ); + rollback to savepoint a; + + -- ov - array column overlaps with input array + select jsonb_pretty( + graphql.resolve($$ + { + accountCollection(filter: {tags: {cd: ["customer", "priority"]}}) { + edges { + node { + id + } + } + } + } + $$) + ); + rollback to savepoint a; + -- variable is - is null select graphql.resolve($$query AAA($nis: FilterIs) { accountCollection(filter: {phone: {is: $nis}}) { edges { node { id } } }}$$, '{"nis": "NULL"}'); rollback to savepoint a; From a792bc12ac4bbf1005292757727e57155e13a9f3 Mon Sep 17 00:00:00 2001 From: Mora Date: Thu, 16 May 2024 17:26:36 -0700 Subject: [PATCH 18/29] removing archived status from seed data --- dockerfiles/db/setup.sql | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dockerfiles/db/setup.sql b/dockerfiles/db/setup.sql index 12fdf736..c663edd4 100644 --- a/dockerfiles/db/setup.sql +++ b/dockerfiles/db/setup.sql @@ -50,7 +50,7 @@ create table blog( ); -create type blog_post_status as enum ('PENDING', 'RELEASED', 'ARCHIVED'); +create type blog_post_status as enum ('PENDING', 'RELEASED'); create table blog_post( @@ -86,7 +86,7 @@ values ((SELECT id FROM blog WHERE name = 'A: Blog 1'), 'Post 1 in A Blog 1', 'Content for post 1 in A Blog 1', '{"tech", "update"}', 'RELEASED', NOW()), ((SELECT id FROM blog WHERE name = 'A: Blog 1'), 'Post 2 in A Blog 1', 'Content for post 2 in A Blog 1', '{"announcement", "tech"}', 'PENDING', NOW()), ((SELECT id FROM blog WHERE name = 'A: Blog 2'), 'Post 1 in A Blog 2', 'Content for post 1 in A Blog 2', '{"personal"}', 'RELEASED', NOW()), - ((SELECT id FROM blog WHERE name = 'A: Blog 2'), 'Post 2 in A Blog 2', 'Content for post 2 in A Blog 2', '{"update"}', 'ARCHIVED', NOW()), + ((SELECT id FROM blog WHERE name = 'A: Blog 2'), 'Post 2 in A Blog 2', 'Content for post 2 in A Blog 2', '{"update"}', 'RELEASED', NOW()), ((SELECT id FROM blog WHERE name = 'A: Blog 3'), 'Post 1 in A Blog 3', 'Content for post 1 in A Blog 3', '{"travel", "adventure"}', 'PENDING', NOW()), ((SELECT id FROM blog WHERE name = 'B: Blog 3'), 'Post 1 in B Blog 3', 'Content for post 1 in B Blog 3', '{"tech", "review"}', 'RELEASED', NOW()), ((SELECT id FROM blog WHERE name = 'B: Blog 3'), 'Post 2 in B Blog 3', 'Content for post 2 in B Blog 3', '{"coding", "tutorial"}', 'PENDING', NOW()); From c2ee53df6a02c0d6d727294039d5edc24f70adb6 Mon Sep 17 00:00:00 2001 From: Mora Date: Thu, 16 May 2024 17:27:39 -0700 Subject: [PATCH 19/29] removing extra comment from seed data --- dockerfiles/db/setup.sql | 1 - 1 file changed, 1 deletion(-) diff --git a/dockerfiles/db/setup.sql b/dockerfiles/db/setup.sql index c663edd4..8c2db0fb 100644 --- a/dockerfiles/db/setup.sql +++ b/dockerfiles/db/setup.sql @@ -80,7 +80,6 @@ values ((select id from account where email ilike 'a%'), 'A: Blog 3', 'a desc3', now()), ((select id from account where email ilike 'b%'), 'B: Blog 3', 'b desc1', now()); --- Sample inserts for blog_post insert into blog_post (blog_id, title, body, tags, status, created_at) values ((SELECT id FROM blog WHERE name = 'A: Blog 1'), 'Post 1 in A Blog 1', 'Content for post 1 in A Blog 1', '{"tech", "update"}', 'RELEASED', NOW()), From dd9784a7e09803f85413650a299dddaf33962d18 Mon Sep 17 00:00:00 2001 From: Mora Date: Thu, 16 May 2024 17:32:15 -0700 Subject: [PATCH 20/29] removing unnecessary array handling from create_filters --- src/builder.rs | 23 ++--------------------- 1 file changed, 2 insertions(+), 21 deletions(-) diff --git a/src/builder.rs b/src/builder.rs index ef551752..a3bfae6b 100644 --- a/src/builder.rs +++ b/src/builder.rs @@ -1137,7 +1137,7 @@ fn create_filters( } } } - gson::Value::Array(values) => if k == AND_FILTER_NAME || k == OR_FILTER_NAME { + gson::Value::Array(values) if k == AND_FILTER_NAME || k == OR_FILTER_NAME => { // If there are no inner filters we avoid creating an argumentless `and`/`or` expression // which would have been anyways compiled away during transpilation if !values.is_empty() { @@ -1171,27 +1171,8 @@ fn create_filters( filters.push(filter_builder); } - } else { - if !values.is_empty() { - for value in values { - if let gson::Value::Object(filter_op_to_value_map) = value { - for (filter_op_str, filter_val) in filter_op_to_value_map { - let filter_op = FilterOp::from_str(filter_op_str)?; - - // Skip absent - // Technically nulls should be treated as literals. It will always filter out all rows - // val null is never true - if filter_val == &gson::Value::Absent { - continue; - } - - filters.push(create_filter_builder_elem(filter_iv, filter_op, filter_val)?); } - } - } - } - } - _ => return Err("Filter re-validation error op_to_value map".to_string()), + _ => return Err("Filter re-validation errror op_to_value map".to_string()), } } Ok(filters) From 498d35c3a6de8088ffeac6313894a108e66edad2 Mon Sep 17 00:00:00 2001 From: Mora Date: Thu, 16 May 2024 17:33:30 -0700 Subject: [PATCH 21/29] removing unnecessary spacing change from create_filters --- src/builder.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/builder.rs b/src/builder.rs index a3bfae6b..038ba03d 100644 --- a/src/builder.rs +++ b/src/builder.rs @@ -1171,7 +1171,7 @@ fn create_filters( filters.push(filter_builder); } - } + } _ => return Err("Filter re-validation errror op_to_value map".to_string()), } } From 26be47c77814af99fd8dbd28b4a87058f6dbb27a Mon Sep 17 00:00:00 2001 From: Mora Date: Thu, 16 May 2024 19:22:46 -0700 Subject: [PATCH 22/29] updating docs to include array column filters --- docs/api.md | 312 ++++++++++++++++++++++++++++++-- docs/assets/demo_schema.graphql | 167 +++++++++++++++++ docs/assets/demo_schema.sql | 1 + 3 files changed, 460 insertions(+), 20 deletions(-) diff --git a/docs/api.md b/docs/api.md index d6f71a7b..f6ff48d4 100644 --- a/docs/api.md +++ b/docs/api.md @@ -526,6 +526,7 @@ Where the `Filter` type enumerates filterable fields and their associated id: IntFilter name: StringFilter description: StringFilter + tags: StringListFilter createdAt: DatetimeFilter updatedAt: DatetimeFilter and: [BlogFilter!] @@ -575,6 +576,25 @@ Where the `
Filter` type enumerates filterable fields and their associated } ``` +=== "StringListFilter" + + ```graphql + """ + Boolean expression comparing fields on type "StringList" + """ + input StringListFilter { + cd: [String!] + cs: [String!] + eq: [String!] + gt: [String!] + gte: [String!] + lt: [String!] + lte: [String!] + neq: [String!] + ov: [String!] + } + ``` + === "FilterIs" ```graphql @@ -587,21 +607,24 @@ Where the `
Filter` type enumerates filterable fields and their associated The following list shows the operators that may be available on `Filter` types. -| Operator | Description | -| ----------- | -------------------------------------------------| -| eq | Equal To | -| neq | Not Equal To | -| gt | Greater Than | -| gte | Greater Than Or Equal To | -| in | Contained by Value List | -| lt | Less Than | -| lte | Less Than Or Equal To | -| is | Null or Not Null | -| startsWith | Starts with prefix | -| like | Pattern Match. '%' as wildcard | -| ilike | Pattern Match. '%' as wildcard. Case Insensitive | -| regex | POSIX Regular Expression Match | -| iregex | POSIX Regular Expression Match. Case Insensitive | +| Operator | Description | +|------------|-------------------------------------------------------------------| +| eq | Equal To | +| neq | Not Equal To | +| gt | Greater Than | +| gte | Greater Than Or Equal To | +| in | Contained by Value List | +| lt | Less Than | +| lte | Less Than Or Equal To | +| is | Null or Not Null | +| startsWith | Starts with prefix | +| like | Pattern Match. '%' as wildcard | +| ilike | Pattern Match. '%' as wildcard. Case Insensitive | +| regex | POSIX Regular Expression Match | +| iregex | POSIX Regular Expression Match. Case Insensitive | +| cs | Contains. Applies to array columns only. | +| cd | Contained in. Applies to array columns only. | +| ov | Overlap (have points in common). Applies to array columns only. | Not all operators are available on every `Filter` type. For example, `UUIDFilter` only supports `eq` and `neq` because `UUID`s are not ordered. @@ -650,7 +673,256 @@ Not all operators are available on every `Filter` type. For example, `UUID ``` -** Example: and/or ** +**Example: array column** + +The `cs` filter is used to return results where all the elements in the input array appear in the array column. + +=== "`cs` Filter Query" + ```graphql + { + blogCollection( + filter: {tags: {cs: ["tech", "innovation"]}}, + ) { + edges { + cursor + node { + id + name + tags + createdAt + } + } + } + } + ``` + +=== "`cs` Filter Result" + ```json + { + "data": { + "blogCollection": { + "edges": [ + { + "node": { + "id": 1, + "name": "A: Blog 1", + "createdAt": "2023-07-24T04:01:09.882781", + "tags": ["tech", "innovation"] + }, + "cursor": "WzFd" + }, + { + "node": { + "id": 2, + "name": "A: Blog 2", + "createdAt": "2023-07-24T04:01:09.882781", + "tags": ["tech", "innovation", "entrepreneurship"] + }, + "cursor": "WzJd" + } + ] + } + } + } + ``` + +The `cs` filter can also accept a single scalar. + +=== "`cs` Filter with Scalar Query" + ```graphql + { + blogCollection( + filter: {tags: {cs: "tech"}}, + ) { + edges { + cursor + node { + id + name + tags + createdAt + } + } + } + } + ``` + +=== "`cs` Filter with Scalar Result" + ```json + { + "data": { + "blogCollection": { + "edges": [ + { + "node": { + "id": 1, + "name": "A: Blog 1", + "createdAt": "2023-07-24T04:01:09.882781", + "tags": ["tech", "innovation"] + }, + "cursor": "WzFd" + }, + { + "node": { + "id": 2, + "name": "A: Blog 2", + "createdAt": "2023-07-24T04:01:09.882781", + "tags": ["tech", "innovation", "entrepreneurship"] + }, + "cursor": "WzJd" + } + ] + } + } + } + ``` + +The `cd` filter is used to return results where every element of the array column appears in the input array. + +=== "`cd` Filter Query" + ```graphql + { + blogCollection( + filter: {tags: {cd: ["entrepreneurship", "innovation", "tech"]}}, + ) { + edges { + cursor + node { + id + name + tags + createdAt + } + } + } + } + ``` + +=== "`cd` Filter Result" + ```json + { + "data": { + "blogCollection": { + "edges": [ + { + "node": { + "id": 3, + "name": "A: Blog 3", + "createdAt": "2023-07-24T04:01:09.882781", + "tags": ["innovation", "entrepreneurship"] + }, + "cursor": "WzNd" + } + ] + } + } + } + ``` + +The `cd` filter can also accept a single scalar. In this case, only results where the only element in the array column is the input scalar. + +=== "`cd` Filter with Scalar Query" + ```graphql + { + blogCollection( + filter: {tags: {cd: "travel"}}, + ) { + edges { + cursor + node { + id + name + tags + createdAt + } + } + } + } + ``` + +=== "`cd` Filter with Scalar Result" + ```json + { + "data": { + "blogCollection": { + "edges": [ + { + "node": { + "id": 4, + "name": "A: Blog 4", + "createdAt": "2023-07-24T04:01:09.882781", + "tags": ["travel"] + }, + "cursor": "WzPd" + } + ] + } + } + } + ``` + +The `ov` filter is used to return results where the array column and the input array have at least one element in common. + +=== "`ov` Filter Query" + ```graphql + { + blogCollection( + filter: {tags: {ov: ["tech", "travel"]}}, + ) { + edges { + cursor + node { + id + name + tags + createdAt + } + } + } + } + ``` + +=== "`ov` Filter Result" + ```json + { + "data": { + "blogCollection": { + "edges": [ + { + "node": { + "id": 1, + "name": "A: Blog 1", + "createdAt": "2023-07-24T04:01:09.882781", + "tags": ["tech", "innovation"] + }, + "cursor": "WzFd" + }, + { + "node": { + "id": 2, + "name": "A: Blog 2", + "createdAt": "2023-07-24T04:01:09.882781", + "tags": ["tech", "innovation", "entrepreneurship"] + }, + "cursor": "WzJd" + }, + { + "node": { + "id": 4, + "name": "A: Blog 4", + "createdAt": "2023-07-24T04:01:09.882781", + "tags": ["travel"] + }, + "cursor": "WzPd" + } + ] + } + } + } + ``` + + +**Example: and/or** Multiple filters can be combined with `and`, `or` and `not` operators. The `and` and `or` operators accept a list of `Filter`. @@ -754,7 +1026,7 @@ Multiple filters can be combined with `and`, `or` and `not` operators. The `and` ``` -** Example: not ** +**Example: not** `not` accepts a single `Filter`. @@ -819,7 +1091,7 @@ Multiple filters can be combined with `and`, `or` and `not` operators. The `and` ``` -** Example: nested composition ** +**Example: nested composition** The `and`, `or` and `not` operators can be arbitrarily nested inside each other. @@ -888,7 +1160,7 @@ The `and`, `or` and `not` operators can be arbitrarily nested inside each other. } ``` -** Example: empty ** +**Example: empty** Empty filters are ignored, i.e. they behave as if the operator was not specified at all. @@ -963,7 +1235,7 @@ Empty filters are ignored, i.e. they behave as if the operator was not specified ``` -** Example: implicit and ** +**Example: implicit and** Multiple column filters at the same level will be implicitly combined with boolean `and`. In the following example the `id: {eq: 1}` and `name: {eq: "A: Blog 1"}` will be `and`ed. diff --git a/docs/assets/demo_schema.graphql b/docs/assets/demo_schema.graphql index bbf89ceb..33095f4d 100644 --- a/docs/assets/demo_schema.graphql +++ b/docs/assets/demo_schema.graphql @@ -125,6 +125,21 @@ input BigFloatFilter { neq: BigFloat } +""" +Boolean expression comparing fields on type "BigFloatList" +""" +input BigFloatListFilter { + cd: [BigFloat!] + cs: [BigFloat!] + eq: [BigFloat!] + gt: [BigFloat!] + gte: [BigFloat!] + lt: [BigFloat!] + lte: [BigFloat!] + neq: [BigFloat!] + ov: [BigFloat!] +} + """An arbitrary size integer represented as a string""" scalar BigInt @@ -142,6 +157,21 @@ input BigIntFilter { neq: BigInt } +""" +Boolean expression comparing fields on type "BigIntList" +""" +input BigIntListFilter { + cd: [BigInt!] + cs: [BigInt!] + eq: [BigInt!] + gt: [BigInt!] + gte: [BigInt!] + lt: [BigInt!] + lte: [BigInt!] + neq: [BigInt!] + ov: [BigInt!] +} + type Blog implements Node { """Globally Unique Record Identifier""" nodeId: ID! @@ -149,6 +179,7 @@ type Blog implements Node { ownerId: Int! name: String! description: String + tags: [String] createdAt: Datetime! updatedAt: Datetime! owner: Account! @@ -201,6 +232,7 @@ input BlogFilter { ownerId: IntFilter name: StringFilter description: StringFilter + tags: StringListFilter createdAt: DatetimeFilter updatedAt: DatetimeFilter nodeId: IDFilter @@ -384,6 +416,21 @@ input BooleanFilter { is: FilterIs } +""" +Boolean expression comparing fields on type "BooleanList" +""" +input BooleanListFilter { + cd: [Boolean!] + cs: [Boolean!] + eq: [Boolean!] + gt: [Boolean!] + gte: [Boolean!] + lt: [Boolean!] + lte: [Boolean!] + neq: [Boolean!] + ov: [Boolean!] +} + """ An opaque string using for tracking a position in results during pagination """ @@ -406,6 +453,21 @@ input DateFilter { neq: Date } +""" +Boolean expression comparing fields on type "DateList" +""" +input DateListFilter { + cd: [Date!] + cs: [Date!] + eq: [Date!] + gt: [Date!] + gte: [Date!] + lt: [Date!] + lte: [Date!] + neq: [Date!] + ov: [Date!] +} + """A date and time""" scalar Datetime @@ -423,6 +485,21 @@ input DatetimeFilter { neq: Datetime } +""" +Boolean expression comparing fields on type "DatetimeList" +""" +input DatetimeListFilter { + cd: [Datetime!] + cs: [Datetime!] + eq: [Datetime!] + gt: [Datetime!] + gte: [Datetime!] + lt: [Datetime!] + lte: [Datetime!] + neq: [Datetime!] + ov: [Datetime!] +} + enum FilterIs { NULL NOT_NULL @@ -442,6 +519,21 @@ input FloatFilter { neq: Float } +""" +Boolean expression comparing fields on type "FloatList" +""" +input FloatListFilter { + cd: [Float!] + cs: [Float!] + eq: [Float!] + gt: [Float!] + gte: [Float!] + lt: [Float!] + lte: [Float!] + neq: [Float!] + ov: [Float!] +} + """ Boolean expression comparing fields on type "ID" """ @@ -449,6 +541,21 @@ input IDFilter { eq: ID } +""" +Boolean expression comparing fields on type "IDList" +""" +input IDListFilter { + cd: [ID!] + cs: [ID!] + eq: [ID!] + gt: [ID!] + gte: [ID!] + lt: [ID!] + lte: [ID!] + neq: [ID!] + ov: [ID!] +} + """ Boolean expression comparing fields on type "Int" """ @@ -463,6 +570,21 @@ input IntFilter { neq: Int } +""" +Boolean expression comparing fields on type "IntList" +""" +input IntListFilter { + cd: [Int!] + cs: [Int!] + eq: [Int!] + gt: [Int!] + gte: [Int!] + lt: [Int!] + lte: [Int!] + neq: [Int!] + ov: [Int!] +} + """A Javascript Object Notation value serialized as a string""" scalar JSON @@ -703,6 +825,21 @@ input StringFilter { startsWith: String } +""" +Boolean expression comparing fields on type "StringList" +""" +input StringListFilter { + cd: [String!] + cs: [String!] + eq: [String!] + gt: [String!] + gte: [String!] + lt: [String!] + lte: [String!] + neq: [String!] + ov: [String!] +} + """A time without date information""" scalar Time @@ -720,6 +857,21 @@ input TimeFilter { neq: Time } +""" +Boolean expression comparing fields on type "TimeList" +""" +input TimeListFilter { + cd: [Time!] + cs: [Time!] + eq: [Time!] + gt: [Time!] + gte: [Time!] + lt: [Time!] + lte: [Time!] + neq: [Time!] + ov: [Time!] +} + """A universally unique identifier""" scalar UUID @@ -732,3 +884,18 @@ input UUIDFilter { is: FilterIs neq: UUID } + +""" +Boolean expression comparing fields on type "UUIDList" +""" +input UUIDListFilter { + cd: [UUID!] + cs: [UUID!] + eq: [UUID!] + gt: [UUID!] + gte: [UUID!] + lt: [UUID!] + lte: [UUID!] + neq: [UUID!] + ov: [UUID!] +} diff --git a/docs/assets/demo_schema.sql b/docs/assets/demo_schema.sql index 58a8a18d..2a74093b 100644 --- a/docs/assets/demo_schema.sql +++ b/docs/assets/demo_schema.sql @@ -16,6 +16,7 @@ create table blog( owner_id integer not null references account(id), name varchar(255) not null, description varchar(255), + tags text[], created_at timestamp not null, updated_at timestamp not null ); From 761f2261b1eaa7d4a8991b90c5515dcd9b1dc8a4 Mon Sep 17 00:00:00 2001 From: Mora Date: Thu, 16 May 2024 19:27:29 -0700 Subject: [PATCH 23/29] adding missing result to docs --- docs/api.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/api.md b/docs/api.md index f6ff48d4..7bc68550 100644 --- a/docs/api.md +++ b/docs/api.md @@ -804,6 +804,15 @@ The `cd` filter is used to return results where every element of the array colum "data": { "blogCollection": { "edges": [ + { + "node": { + "id": 1, + "name": "A: Blog 1", + "createdAt": "2023-07-24T04:01:09.882781", + "tags": ["tech", "innovation"] + }, + "cursor": "WzFd" + }, { "node": { "id": 3, From e658d8371d6fa2392dc2e0588d6113d4e0954dbf Mon Sep 17 00:00:00 2001 From: Mora Date: Sat, 18 May 2024 18:15:11 -0700 Subject: [PATCH 24/29] bumping minor version --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index d9f26e33..e93fcb84 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pg_graphql" -version = "1.5.4" +version = "1.5.5" edition = "2021" [lib] From 3e3fb845d55fb4c26c36263b1d35a01eeaf786aa Mon Sep 17 00:00:00 2001 From: Mora Date: Sat, 18 May 2024 18:15:11 -0700 Subject: [PATCH 25/29] bumping patch version --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index d9f26e33..e93fcb84 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pg_graphql" -version = "1.5.4" +version = "1.5.5" edition = "2021" [lib] From 2e2a6be877d48a01a7c84083e8060aed7e33c614 Mon Sep 17 00:00:00 2001 From: Mora Date: Sat, 25 May 2024 17:51:05 -0700 Subject: [PATCH 26/29] removing bump on patch version --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index e93fcb84..d9f26e33 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pg_graphql" -version = "1.5.5" +version = "1.5.4" edition = "2021" [lib] From c1a4ebe7f0e6973a10ad66d6b7e1c7a7b2005772 Mon Sep 17 00:00:00 2001 From: Mora Date: Sat, 25 May 2024 18:01:47 -0700 Subject: [PATCH 27/29] removing unwrap --- src/graphql.rs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/graphql.rs b/src/graphql.rs index ae4300d8..09d9339f 100644 --- a/src/graphql.rs +++ b/src/graphql.rs @@ -1130,10 +1130,12 @@ impl FilterTypeType { match &self.entity { FilterableType::Scalar(s) => s.name().expect("scalar name should exist"), FilterableType::Enum(e) => e.name().expect("enum type name should exist"), - FilterableType::List(l) => match l.of_type().unwrap().name() { - None => panic!("inner list type name should exist"), - Some(name) => format!("{}List", name) - }, + FilterableType::List(l) => format!( + "{}List", + l.of_type() + .expect("inner list type should exist") + .name() + .expect("inner list type name should exist")) } } } From ca2890b2f648ed8513adc8265c4c223b3c58bea0 Mon Sep 17 00:00:00 2001 From: Mora Date: Sat, 25 May 2024 18:15:41 -0700 Subject: [PATCH 28/29] correcting ov test --- test/expected/resolve_connection_filter.out | 7 ++++++- test/sql/resolve_connection_filter.sql | 2 +- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/test/expected/resolve_connection_filter.out b/test/expected/resolve_connection_filter.out index a6795686..4504278b 100644 --- a/test/expected/resolve_connection_filter.out +++ b/test/expected/resolve_connection_filter.out @@ -374,7 +374,7 @@ begin; select jsonb_pretty( graphql.resolve($$ { - accountCollection(filter: {tags: {cd: ["customer", "priority"]}}) { + accountCollection(filter: {tags: {ov: ["customer", "priority"]}}) { edges { node { id @@ -399,6 +399,11 @@ begin; "node": { + "id": 2+ } + + }, + + { + + "node": { + + "id": 3+ + } + } + ] + } + diff --git a/test/sql/resolve_connection_filter.sql b/test/sql/resolve_connection_filter.sql index cfa8b772..777bff76 100644 --- a/test/sql/resolve_connection_filter.sql +++ b/test/sql/resolve_connection_filter.sql @@ -190,7 +190,7 @@ begin; select jsonb_pretty( graphql.resolve($$ { - accountCollection(filter: {tags: {cd: ["customer", "priority"]}}) { + accountCollection(filter: {tags: {ov: ["customer", "priority"]}}) { edges { node { id From edcf8e0bb29b62716afb6f93aa2127f731e5bf60 Mon Sep 17 00:00:00 2001 From: Mora Date: Sat, 25 May 2024 18:22:18 -0700 Subject: [PATCH 29/29] correcting wording for cd docs --- docs/api.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/api.md b/docs/api.md index 7bc68550..caf4d5ec 100644 --- a/docs/api.md +++ b/docs/api.md @@ -828,7 +828,7 @@ The `cd` filter is used to return results where every element of the array colum } ``` -The `cd` filter can also accept a single scalar. In this case, only results where the only element in the array column is the input scalar. +The `cd` filter can also accept a single scalar. In this case, only results where the only element in the array column is the input scalar are returned. === "`cd` Filter with Scalar Query" ```graphql