trying to get computed functions to work

Author: scoop1120

crates/deno-subsystem/deno-graphql-resolver/extension/exograph.js

@@ -25,7 +25,8 @@ export function exograph_version() {
 //
 globalThis.ExographExtension = ({
     executeQuery: async function (query_string, variables) {
-        const result = await op_exograph_execute_query(query_string, variables);
+        const normalizedVars = variables === undefined ? null : variables;
+        const result = await op_exograph_execute_query(query_string, normalizedVars);
         return result;
     },
 
@@ -34,7 +35,9 @@ globalThis.ExographExtension = ({
     },
 
     executeQueryPriv: async function (query_string, variables, context_override) {
-        const result = await op_exograph_execute_query_priv(query_string, variables, context_override);
+        const normalizedVars = variables === undefined ? null : variables;
+        const normalizedContext = context_override === undefined ? null : context_override;
+        const result = await op_exograph_execute_query_priv(query_string, normalizedVars, normalizedContext);
         return result;
     },
 })

crates/deno-subsystem/deno-graphql-resolver/src/exograph_ops.rs

@@ -34,6 +34,33 @@ pub async fn op_exograph_execute_query_helper(
     variables: Option<Value>,
     context_override: Value,
 ) -> Result<Value, DenoExecutionError> {
+    let query_str = query_string.as_str().ok_or_else(|| {
+        DenoExecutionError::Explicit(format!(
+            "executeQuery expects query_string to be a string, got {}",
+            query_string
+        ))
+    })?;
+    let variables = match variables {
+        Some(Value::Object(obj)) => Some(obj),
+        Some(other) => {
+            return Err(DenoExecutionError::Explicit(format!(
+                "executeQuery expects variables to be an object, got {}",
+                other
+            )));
+        }
+        None => None,
+    };
+    let context_override = match context_override {
+        Value::Null => Value::Null,
+        Value::Object(_) => context_override,
+        other => {
+            return Err(DenoExecutionError::Explicit(format!(
+                "executeQuery expects context_override to be an object or null, got {}",
+                other
+            )));
+        }
+    };
+
     let (response_sender, response_receiver) = tokio::sync::oneshot::channel();
 
     let sender = {
@@ -43,8 +70,8 @@ pub async fn op_exograph_execute_query_helper(
 
     sender
         .send(RequestFromDenoMessage::ExographExecute {
-            query_string: query_string.as_str().unwrap().to_string(),
-            variables: variables.as_ref().map(|o| o.as_object().unwrap().clone()),
+            query_string: query_str.to_string(),
+            variables,
             context_override,
             response_sender,
         })

crates/deno-subsystem/deno-graphql-resolver/src/exograph_shim.js

@@ -9,7 +9,8 @@
 
 ({
     executeQuery: async function (query_string, variables) {
-        const result = await ExographExtension.executeQuery(query_string, variables);
+        const normalizedVars = variables === undefined ? null : variables;
+        const result = await ExographExtension.executeQuery(query_string, normalizedVars);
         return result;
     },
 

crates/postgres-subsystem/postgres-graphql-builder/src/predicate_builder.rs

@@ -134,6 +134,17 @@ pub fn build_shallow(types: &MappedArena<ResolvedType>, building: &mut SystemCon
                         .predicate_types
                         .add(&shallow_type.name.clone(), shallow_type);
                 }
+                // Some filter type (for one-to-many relation filters)
+                {
+                    let shallow_type = PredicateParameterType {
+                        name: get_some_filter_type_name(&c.name),
+                        kind: PredicateParameterTypeKind::ImplicitEqual, // Will be set to the correct value in expand_type
+                        underlying_type: None,
+                    };
+                    building
+                        .predicate_types
+                        .add(&shallow_type.name.clone(), shallow_type);
+                }
                 // Unique filter type
                 {
                     let shallow_type = PredicateParameterType {
@@ -178,21 +189,31 @@ pub fn build_expanded(resolved_env: &ResolvedTypeEnv, building: &mut SystemConte
             continue;
         }
 
+        let resolved_type = resolved_env
+            .resolved_types
+            .get_by_key(&entity_type.name)
+            .unwrap();
+
         {
             let param_type_name = get_filter_type_name(&entity_type.name);
             let existing_param_id = building.predicate_types.get_id(&param_type_name);
 
-            let resolved_type = resolved_env
-                .resolved_types
-                .get_by_key(&entity_type.name)
-                .unwrap();
-
             let new_kind = expand_entity_type(resolved_type, entity_type, building);
             let param_type = &mut building.predicate_types[existing_param_id.unwrap()];
             param_type.kind = new_kind;
             param_type.underlying_type = Some(entity_type_id);
         }
 
+        {
+            let param_type_name = get_some_filter_type_name(&entity_type.name);
+            let existing_param_id = building.predicate_types.get_id(&param_type_name);
+            let new_kind = expand_some_filter_type(resolved_type, entity_type, building);
+
+            let param_type = &mut building.predicate_types[existing_param_id.unwrap()];
+            param_type.kind = new_kind;
+            param_type.underlying_type = Some(entity_type_id);
+        }
+
         {
             let param_type_name = get_unique_filter_type_name(&entity_type.name);
             let existing_param_id = building.predicate_types.get_id(&param_type_name);
@@ -217,6 +238,10 @@ pub fn get_array_filter_type_name(type_name: &str) -> String {
     format!("{type_name}ArrayFilter")
 }
 
+pub fn get_some_filter_type_name(type_name: &str) -> String {
+    format!("{type_name}SomeFilter")
+}
+
 fn expand_primitive_type(
     typ: &PostgresPrimitiveType,
     building: &SystemContextBuilding,
@@ -293,6 +318,11 @@ fn expand_entity_type(
                 && matches!(field.typ.base_type(), FieldType::List(_))
             {
                 get_array_filter_type_name(field.typ.name())
+            } else if matches!(
+                field.relation,
+                PostgresRelation::OneToMany(_) | PostgresRelation::Transitive(_)
+            ) {
+                get_some_filter_type_name(field.typ.name())
             } else {
                 get_filter_type_name(field.typ.name())
             };
@@ -375,6 +405,49 @@ fn expand_entity_type(
     }
 }
 
+fn expand_some_filter_type(
+    resolved_type: &ResolvedType,
+    entity_type: &EntityType,
+    building: &SystemContextBuilding,
+) -> PredicateParameterTypeKind {
+    let (mut field_params, logical_op_params) =
+        match expand_entity_type(resolved_type, entity_type, building) {
+            PredicateParameterTypeKind::Composite {
+                field_params,
+                logical_op_params,
+            } => (field_params, logical_op_params),
+            other => return other,
+        };
+
+    let param_type_name = get_filter_type_name(&entity_type.name);
+    let param_type_id = building
+        .predicate_types
+        .get_id(&param_type_name)
+        .unwrap_or_else(|| panic!("Could not find predicate type '{param_type_name}'"));
+
+    let param_type =
+        FieldType::Optional(Box::new(FieldType::Plain(PredicateParameterTypeWrapper {
+            name: param_type_name,
+            type_id: param_type_id,
+        })));
+
+    field_params.insert(
+        0,
+        PredicateParameter {
+            name: "some".to_string(),
+            typ: param_type,
+            column_path_link: None,
+            access: None,
+            vector_distance_function: None,
+        },
+    );
+
+    PredicateParameterTypeKind::Composite {
+        field_params,
+        logical_op_params,
+    }
+}
+
 fn expand_unique_type(
     entity_type: &EntityType,
     building: &SystemContextBuilding,

crates/postgres-subsystem/postgres-graphql-resolver/src/abstract_operation_resolver.rs

@@ -35,20 +35,22 @@ pub async fn resolve_operation<'e>(
         return_type,
     } = resolved_operation;
 
-    let mut tx = request_context
-        .system_context
-        .transaction_holder
-        .try_lock()
-        .unwrap();
+    let result = {
+        let mut tx = request_context
+            .system_context
+            .transaction_holder
+            .try_lock()
+            .unwrap();
 
-    let result = subsystem_resolver
-        .executor
-        .execute(
-            operation,
-            &mut tx,
-            &subsystem_resolver.subsystem.core_subsystem.database,
-        )
-        .await;
+        subsystem_resolver
+            .executor
+            .execute(
+                operation,
+                &mut tx,
+                &subsystem_resolver.subsystem.core_subsystem.database,
+            )
+            .await
+    };
 
     if let Err(DatabaseError::Precheck(_)) = result {
         return Err(PostgresExecutionError::Authorization);

crates/postgres-subsystem/postgres-graphql-resolver/src/predicate_mapper.rs

@@ -408,8 +408,7 @@ impl<'a> SQLMapper<'a, AbstractPredicate> for PredicateParamInput<'a> {
                                         &self.parent_column_path,
                                         subsystem,
                                         parameter.name.as_str() == "in",
-                                    )
-                                    .expect("Could not get operands");
+                                    )?;
 
                                     Ok(predicate_from_name(
                                         &parameter.name,

crates/testing/src/loader/test_suite.rs

@@ -135,10 +135,12 @@ fn collect_exo_projects(root_directory: &Path) -> Vec<PathBuf> {
             if subdir.path().is_dir() {
                 let subdir_path = subdir.path();
                 // Skip directories with .skip suffix
-                if let Some(dir_name) = subdir_path.file_name() {
-                    if dir_name.to_str().map_or(false, |s| s.ends_with(".skip")) {
-                        continue;
-                    }
+                if subdir_path
+                    .file_name()
+                    .and_then(|n| n.to_str())
+                    .is_some_and(|s| s.ends_with(".skip"))
+                {
+                    continue;
                 }
                 if is_exoproject_with_tests(&subdir_path) {
                     acc.push(subdir_path);

integration-tests/access-expressions/schema-tests/introspection.expected.graphql

@@ -119,6 +119,21 @@ input AdminNoteReferenceInput {
   id: Int!
 }
 
+"""
+Predicate for the `AdminNote` type parameter. 
+If a field is omitted, no filter is applied for that field.
+To check a field against null, use a `<field name>: null` filter
+"""
+input AdminNoteSomeFilter {
+  some: AdminNoteFilter
+  id: IntFilter
+  content: StringFilter
+  user: UserFilter
+  and: [AdminNoteFilter!]
+  or: [AdminNoteFilter!]
+  not: AdminNoteFilter
+}
+
 input AdminNoteUpdateInput {
   id: Int
   content: String
@@ -333,6 +348,21 @@ input MembershipReferenceInput {
   id: Int!
 }
 
+"""
+Predicate for the `Membership` type parameter. 
+If a field is omitted, no filter is applied for that field.
+To check a field against null, use a `<field name>: null` filter
+"""
+input MembershipSomeFilter {
+  some: MembershipFilter
+  id: IntFilter
+  kind: StringFilter
+  user: UserFilter
+  and: [MembershipFilter!]
+  or: [MembershipFilter!]
+  not: MembershipFilter
+}
+
 input MembershipUpdateInput {
   id: Int
   kind: String
@@ -440,8 +470,8 @@ To check a field against null, use a `<field name>: null` filter
 input UserFilter {
   id: IntFilter
   name: StringFilter
-  membership: MembershipFilter
-  notes: AdminNoteFilter
+  membership: MembershipSomeFilter
+  notes: AdminNoteSomeFilter
   and: [UserFilter!]
   or: [UserFilter!]
   not: UserFilter

integration-tests/access-null-field-check/schema-tests/introspection.expected.graphql

@@ -60,6 +60,21 @@ input IssueReferenceInput {
   id: Int!
 }
 
+"""
+Predicate for the `Issue` type parameter. 
+If a field is omitted, no filter is applied for that field.
+To check a field against null, use a `<field name>: null` filter
+"""
+input IssueSomeFilter {
+  some: IssueFilter
+  id: IntFilter
+  title: StringFilter
+  assignee: UserFilter
+  and: [IssueFilter!]
+  or: [IssueFilter!]
+  not: IssueFilter
+}
+
 input IssueUpdateInput {
   id: Int
   title: String
@@ -127,7 +142,7 @@ To check a field against null, use a `<field name>: null` filter
 input UserFilter {
   id: IntFilter
   name: StringFilter
-  assignedIssues: IssueFilter
+  assignedIssues: IssueSomeFilter
   and: [UserFilter!]
   or: [UserFilter!]
   not: UserFilter

integration-tests/basic-model-no-auth/schema-tests/introspection.expected.graphql

@@ -64,6 +64,23 @@ input ConcertReferenceInput {
   id: Int!
 }
 
+"""
+Predicate for the `Concert` type parameter. 
+If a field is omitted, no filter is applied for that field.
+To check a field against null, use a `<field name>: null` filter
+"""
+input ConcertSomeFilter {
+  some: ConcertFilter
+  id: IntFilter
+  title: StringFilter
+  venue: VenueFilter
+  published: BooleanFilter
+  price: DecimalFilter
+  and: [ConcertFilter!]
+  or: [ConcertFilter!]
+  not: ConcertFilter
+}
+
 input ConcertUpdateInput {
   id: Int
   title: String
@@ -194,7 +211,7 @@ To check a field against null, use a `<field name>: null` filter
 input VenueFilter {
   id: IntFilter
   name: StringFilter
-  concerts: ConcertFilter
+  concerts: ConcertSomeFilter
   published: BooleanFilter
   latitude: FloatFilter
   and: [VenueFilter!]