Hide implementation details of QueryOptions

query-engine/core/src/query_ast/read.rs

@@ -92,6 +92,34 @@ impl Display for ReadQuery {
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum QueryOption {
     ThrowOnEmpty,
+    Other,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct QueryOptions(BitFlags<QueryOption>);
+
+// Allows for: QueryOption::ThrowOnEmpty.into()  to be a QueryOptions
+impl From<QueryOption> for QueryOptions {
+    fn from(options: QueryOption) -> Self {
+        QueryOptions(options.into())
+    }
+}
+
+// Allows for: (QueryOption::ThrowOnEmpty | QueryOption::Other).into()  to be a QueryOptions
+impl From<BitFlags<QueryOption>> for QueryOptions {
+    fn from(options: BitFlags<QueryOption>) -> Self {
+        QueryOptions(options)
+    }
+}
+
+impl QueryOptions {
+    pub fn none() -> Self {
+        Self(BitFlags::empty())
+    }
+
+    pub fn contains(&self, option: QueryOption) -> bool {
+        self.0.contains(option)
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -104,7 +132,7 @@ pub struct RecordQuery {
     pub nested: Vec<ReadQuery>,
     pub selection_order: Vec<String>,
     pub aggregation_selections: Vec<RelAggregationSelection>,
-    pub options: BitFlags<QueryOption>,
+    pub options: QueryOptions,
 }
 
 #[derive(Debug, Clone)]
@@ -117,7 +145,7 @@ pub struct ManyRecordsQuery {
     pub nested: Vec<ReadQuery>,
     pub selection_order: Vec<String>,
     pub aggregation_selections: Vec<RelAggregationSelection>,
-    pub options: BitFlags<QueryOption>,
+    pub options: QueryOptions,
 }
 
 #[derive(Debug, Clone)]

query-engine/core/src/query_graph/mod.rs

@@ -3,13 +3,13 @@ mod formatters;
 mod guard;
 mod transformers;
 
-use enumflags2::BitFlags;
 pub use error::*;
 pub use formatters::*;
 pub use transformers::*;
 
 use crate::{
-    interpreter::ExpressionResult, FilteredQuery, ManyRecordsQuery, Query, QueryGraphBuilderResult, ReadQuery,
+    interpreter::ExpressionResult, FilteredQuery, ManyRecordsQuery, Query, QueryGraphBuilderResult, QueryOptions,
+    ReadQuery,
 };
 use connector::{IntoFilter, QueryArguments};
 use guard::*;
@@ -819,7 +819,7 @@ impl QueryGraph {
                 nested: vec![],
                 selection_order: vec![],
                 aggregation_selections: vec![],
-                options: BitFlags::EMPTY,
+                options: QueryOptions::none(),
             });
 
             let query = Query::Read(read_query);

query-engine/core/src/query_graph_builder/read/many.rs

@@ -1,21 +1,20 @@
 use super::*;
-use crate::{query_document::ParsedField, ManyRecordsQuery, QueryOption, ReadQuery};
-use enumflags2::BitFlags;
+use crate::{query_document::ParsedField, ManyRecordsQuery, QueryOption, QueryOptions, ReadQuery};
 use prisma_models::ModelRef;
 
 pub fn find_many(field: ParsedField, model: ModelRef) -> QueryGraphBuilderResult<ReadQuery> {
-    find_many_with_options(field, model, BitFlags::EMPTY)
+    find_many_with_options(field, model, QueryOptions::none())
 }
 
 pub fn find_many_or_throw(field: ParsedField, model: ModelRef) -> QueryGraphBuilderResult<ReadQuery> {
-    find_many_with_options(field, model, BitFlags::from_flag(QueryOption::ThrowOnEmpty))
+    find_many_with_options(field, model, QueryOption::ThrowOnEmpty.into())
 }
 
 #[inline]
 fn find_many_with_options(
     field: ParsedField,
     model: ModelRef,
-    options: BitFlags<QueryOption>,
+    options: QueryOptions,
 ) -> QueryGraphBuilderResult<ReadQuery> {
     let args = extractors::extract_query_args(field.arguments, &model)?;
     let name = field.name;

query-engine/core/src/query_graph_builder/read/one.rs

@@ -1,24 +1,23 @@
 use super::*;
-use crate::{query_document::*, QueryOption, ReadQuery, RecordQuery};
-use enumflags2::BitFlags;
+use crate::{query_document::*, QueryOption, QueryOptions, ReadQuery, RecordQuery};
 use prisma_models::ModelRef;
 use schema_builder::constants::args;
 use std::convert::TryInto;
 
 pub fn find_unique(field: ParsedField, model: ModelRef) -> QueryGraphBuilderResult<ReadQuery> {
-    find_unique_with_options(field, model, BitFlags::EMPTY)
+    find_unique_with_options(field, model, QueryOptions::none())
 }
 
 pub fn find_unique_or_throw(field: ParsedField, model: ModelRef) -> QueryGraphBuilderResult<ReadQuery> {
-    find_unique_with_options(field, model, BitFlags::from_flag(QueryOption::ThrowOnEmpty))
+    find_unique_with_options(field, model, QueryOption::ThrowOnEmpty.into())
 }
 
 /// Builds a read query from a parsed incoming read query field.
 #[inline]
 pub fn find_unique_with_options(
     mut field: ParsedField,
     model: ModelRef,
-    options: BitFlags<QueryOption>,
+    options: QueryOptions,
 ) -> QueryGraphBuilderResult<ReadQuery> {
     let filter = match field.arguments.lookup(args::WHERE) {
         Some(where_arg) => {

query-engine/core/src/query_graph_builder/write/utils.rs

@@ -4,7 +4,6 @@ use crate::{
     ParsedInputValue, QueryGraphBuilderError, QueryGraphBuilderResult,
 };
 use connector::{DatasourceFieldName, Filter, RecordFilter, WriteArgs, WriteOperation};
-use enumflags2::BitFlags;
 use indexmap::IndexMap;
 use prisma_models::{FieldSelection, ModelRef, PrismaValue, RelationFieldRef, SelectionResult};
 use psl::dml::ReferentialAction;
@@ -45,7 +44,7 @@ where
         nested: vec![],
         selection_order: vec![],
         aggregation_selections: vec![],
-        options: BitFlags::EMPTY,
+        options: QueryOptions::none(),
     });
 
     Query::Read(read_query)