diff --git a/.github/workflows/publish-prisma-schema-wasm.yml b/.github/workflows/publish-prisma-schema-wasm.yml index 3d4951da042..a452133892c 100644 --- a/.github/workflows/publish-prisma-schema-wasm.yml +++ b/.github/workflows/publish-prisma-schema-wasm.yml @@ -9,11 +9,14 @@ on: inputs: enginesWrapperVersion: required: true + description: 'New @prisma/prisma-schema-wasm package version' enginesHash: required: true + description: 'prisma-engines commit to build' npmDistTag: required: true default: 'latest' + description: 'npm dist-tag (e.g. latest or integration)' jobs: build: @@ -50,7 +53,6 @@ jobs: # # Failure handlers # - - name: Set current job url in SLACK_FOOTER env var if: ${{ failure() }} run: echo "SLACK_FOOTER=<$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID|Click here to go to the job logs>" >> $GITHUB_ENV @@ -58,6 +60,7 @@ jobs: if: ${{ failure() }} uses: rtCamp/action-slack-notify@v2.2.1 env: - SLACK_TITLE: 'prisma-schema-wasm publishing failed :x:' + SLACK_TITLE: 'Building and publishing @prisma/prisma-schema-wasm failed :x:' SLACK_COLOR: '#FF0000' + SLACK_CHANNEL: feed-prisma-schema-wasm-publish-failures SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_WASM_FAILING }} diff --git a/.github/workflows/publish-query-engine-wasm.yml b/.github/workflows/publish-query-engine-wasm.yml new file mode 100644 index 00000000000..b5c791ade61 --- /dev/null +++ b/.github/workflows/publish-query-engine-wasm.yml @@ -0,0 +1,70 @@ +name: Build and publish @prisma/query-engine-wasm +run-name: npm - release @prisma/query-engine-wasm@${{ github.event.inputs.packageVersion }} from ${{ github.event.inputs.enginesHash }} on ${{ github.event.inputs.npmDistTag }} + +concurrency: publish-query-engine-wasm + +on: + # usually triggered via GH Actions Workflow in prisma/engines-wrapper repo + workflow_dispatch: + inputs: + packageVersion: + required: true + description: 'New @prisma/query-engine-wasm package version' + enginesHash: + required: true + description: 'prisma-engines commit to build' + npmDistTag: + required: true + default: 'latest' + description: 'npm dist-tag (e.g. latest or integration)' + +jobs: + build: + name: Build and publish @prisma/query-engine-wasm + runs-on: ubuntu-latest + steps: + - name: Print input + run: echo "${{ toJson(github.event.inputs) }}" + + - uses: actions/checkout@v4 + with: + ref: ${{ github.event.inputs.enginesHash }} + + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + with: + targets: wasm32-unknown-unknown + + - name: Install Node.js + uses: actions/setup-node@v4 + with: + node-version: '20.x' + + - name: Install wasm-pack + run: cargo install wasm-pack + + - name: Build @prisma/query-engine-wasm + run: ./build.sh ${{ github.event.inputs.packageVersion }} + working-directory: ./query-engine/query-engine-wasm + + - name: Set up NPM token for publishing + run: echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > ~/.npmrc + + - name: Publish @prisma/query-engine-wasm + run: npm publish --access public --tag ${{ github.event.inputs.npmDistTag }} + working-directory: ./query-engine/query-engine-wasm/pkg + + # + # Failure handlers + # + - name: Set current job url in SLACK_FOOTER env var + if: ${{ failure() }} + run: echo "SLACK_FOOTER=<$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID|Click here to go to the job logs>" >> $GITHUB_ENV + - name: Slack Notification on Failure + if: ${{ failure() }} + uses: rtCamp/action-slack-notify@v2.2.1 + env: + SLACK_TITLE: 'Building and publishing @prisma/query-engine-wasm failed :x:' + SLACK_COLOR: '#FF0000' + SLACK_CHANNEL: feed-prisma-query-engine-wasm-publish-failures + SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_WASM_FAILING }} diff --git a/Cargo.lock b/Cargo.lock index cd2fe6c6b5c..74f0b840d4f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1082,8 +1082,8 @@ dependencies = [ "indoc 2.0.3", "itertools", "pretty_assertions", - "prisma-models", "psl", + "query-structure", "schema", "serde", "serde_json", @@ -2486,11 +2486,11 @@ dependencies = [ "itertools", "mongodb", "mongodb-client", - "prisma-models", "prisma-value", "psl", "query-connector", "query-engine-metrics", + "query-structure", "rand 0.7.3", "regex", "serde", @@ -3346,22 +3346,6 @@ dependencies = [ "structopt", ] -[[package]] -name = "prisma-models" -version = "0.0.0" -dependencies = [ - "bigdecimal", - "chrono", - "cuid", - "getrandom 0.2.10", - "itertools", - "nanoid", - "prisma-value", - "psl", - "thiserror", - "uuid", -] - [[package]] name = "prisma-schema-build" version = "0.1.0" @@ -3653,8 +3637,8 @@ dependencies = [ "futures", "indexmap 1.9.3", "itertools", - "prisma-models", "prisma-value", + "query-structure", "serde", "serde_json", "thiserror", @@ -3681,10 +3665,10 @@ dependencies = [ "opentelemetry", "petgraph 0.4.13", "pin-project", - "prisma-models", "psl", "query-connector", "query-engine-metrics", + "query-structure", "schema", "serde", "serde_json", @@ -3765,12 +3749,12 @@ dependencies = [ "napi-build", "napi-derive", "opentelemetry", - "prisma-models", "psl", "quaint", "query-connector", "query-core", "query-engine-metrics", + "query-structure", "request-handlers", "serde", "serde_json", @@ -3822,11 +3806,11 @@ dependencies = [ "futures", "js-sys", "log", - "prisma-models", "psl", "quaint", "query-connector", "query-core", + "query-structure", "request-handlers", "serde", "serde-wasm-bindgen", @@ -3845,6 +3829,22 @@ dependencies = [ "wasm-logger", ] +[[package]] +name = "query-structure" +version = "0.0.0" +dependencies = [ + "bigdecimal", + "chrono", + "cuid", + "getrandom 0.2.10", + "itertools", + "nanoid", + "prisma-value", + "psl", + "thiserror", + "uuid", +] + [[package]] name = "query-test-macros" version = "0.1.0" @@ -3870,13 +3870,13 @@ dependencies = [ "nom", "once_cell", "parse-hyperlinks", - "prisma-models", "psl", "qe-setup", "quaint", "query-core", "query-engine", "query-engine-metrics", + "query-structure", "regex", "request-handlers", "serde", @@ -4158,10 +4158,10 @@ dependencies = [ "itertools", "mongodb-query-connector", "once_cell", - "prisma-models", "psl", "quaint", "query-core", + "query-structure", "schema", "serde", "serde_json", @@ -4429,8 +4429,8 @@ version = "0.1.0" dependencies = [ "codspeed-criterion-compat", "once_cell", - "prisma-models", "psl", + "query-structure", "rustc-hash", ] @@ -4942,11 +4942,11 @@ dependencies = [ "itertools", "once_cell", "opentelemetry", - "prisma-models", "prisma-value", "psl", "quaint", "query-connector", + "query-structure", "rand 0.7.3", "serde", "serde_json", diff --git a/Cargo.toml b/Cargo.toml index b32a1a85cf1..eb0d6635ca3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,7 +21,7 @@ members = [ "query-engine/dmmf", "query-engine/driver-adapters", "query-engine/metrics", - "query-engine/prisma-models", + "query-engine/query-structure", "query-engine/query-engine", "query-engine/query-engine-node-api", "query-engine/query-engine-wasm", diff --git a/docker-compose.yml b/docker-compose.yml index 48437b82c50..b9694a2c799 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -282,7 +282,7 @@ services: tmpfs: /var/lib/mariadb vitess-test-8_0: - image: vitess/vttestserver:mysql80@sha256:8bec2644d83cb322eb2cdd596d33c0f858243ba6ade9164c95dfcc519643094e + image: vitess/vttestserver:mysql80@sha256:5a75cf290e45af3ab273bd037bdcf07f799132730f645dbe012684f28d58f8f6 restart: unless-stopped ports: - 33807:33807 @@ -302,7 +302,7 @@ services: retries: 20 vitess-shadow-8_0: - image: vitess/vttestserver:mysql80@sha256:8bec2644d83cb322eb2cdd596d33c0f858243ba6ade9164c95dfcc519643094e + image: vitess/vttestserver:mysql80@sha256:5a75cf290e45af3ab273bd037bdcf07f799132730f645dbe012684f28d58f8f6 restart: unless-stopped ports: - 33808:33807 diff --git a/quaint/src/visitor.rs b/quaint/src/visitor.rs index 8424bc7fbb2..c205b49dd27 100644 --- a/quaint/src/visitor.rs +++ b/quaint/src/visitor.rs @@ -1004,6 +1004,20 @@ pub trait Visitor<'a> { Ok(()) } + fn visit_min(&mut self, min: Minimum<'a>) -> Result { + self.write("MIN")?; + self.surround_with("(", ")", |ref mut s| s.visit_column(min.column))?; + + Ok(()) + } + + fn visit_max(&mut self, max: Maximum<'a>) -> Result { + self.write("MAX")?; + self.surround_with("(", ")", |ref mut s| s.visit_column(max.column))?; + + Ok(()) + } + fn visit_function(&mut self, fun: Function<'a>) -> Result { match fun.typ_ { FunctionType::RowNumber(fun_rownum) => { @@ -1046,12 +1060,10 @@ pub trait Visitor<'a> { self.surround_with("(", ")", |ref mut s| s.visit_expression(*upper.expression))?; } FunctionType::Minimum(min) => { - self.write("MIN")?; - self.surround_with("(", ")", |ref mut s| s.visit_column(min.column))?; + self.visit_min(min)?; } FunctionType::Maximum(max) => { - self.write("MAX")?; - self.surround_with("(", ")", |ref mut s| s.visit_column(max.column))?; + self.visit_max(max)?; } FunctionType::Coalesce(coalesce) => { self.write("COALESCE")?; diff --git a/quaint/src/visitor/postgres.rs b/quaint/src/visitor/postgres.rs index b587a7b5b0e..648b3f0dc1e 100644 --- a/quaint/src/visitor/postgres.rs +++ b/quaint/src/visitor/postgres.rs @@ -627,6 +627,34 @@ impl<'a> Visitor<'a> for Postgres<'a> { Ok(()) } + + fn visit_min(&mut self, min: Minimum<'a>) -> visitor::Result { + // If the inner column is a selected enum, then we cast the result of MIN(enum)::text instead of casting the inner enum column, which changes the behavior of MIN. + let should_cast = min.column.is_enum && min.column.is_selected; + + self.write("MIN")?; + self.surround_with("(", ")", |ref mut s| s.visit_column(min.column.set_is_selected(false)))?; + + if should_cast { + self.write("::text")?; + } + + Ok(()) + } + + fn visit_max(&mut self, max: Maximum<'a>) -> visitor::Result { + // If the inner column is a selected enum, then we cast the result of MAX(enum)::text instead of casting the inner enum column, which changes the behavior of MAX. + let should_cast = max.column.is_enum && max.column.is_selected; + + self.write("MAX")?; + self.surround_with("(", ")", |ref mut s| s.visit_column(max.column.set_is_selected(false)))?; + + if should_cast { + self.write("::text")?; + } + + Ok(()) + } } #[cfg(test)] @@ -1157,4 +1185,15 @@ mod tests { assert_eq!("SELECT \"User\".*, \"Toto\".* FROM \"User\" LEFT JOIN \"Post\" AS \"p\" ON \"p\".\"userId\" = \"User\".\"id\", \"Toto\"", sql); } + + #[test] + fn enum_cast_text_in_min_max_should_be_outside() { + let enum_col = Column::from("enum").set_is_enum(true).set_is_selected(true); + let q = Select::from_table("User") + .value(min(enum_col.clone())) + .value(max(enum_col)); + let (sql, _) = Postgres::build(q).unwrap(); + + assert_eq!("SELECT MIN(\"enum\")::text, MAX(\"enum\")::text FROM \"User\"", sql); + } } diff --git a/query-engine/connector-test-kit-rs/query-engine-tests/tests/new/regressions/mod.rs b/query-engine/connector-test-kit-rs/query-engine-tests/tests/new/regressions/mod.rs index 0714015efd0..252ba620b5f 100644 --- a/query-engine/connector-test-kit-rs/query-engine-tests/tests/new/regressions/mod.rs +++ b/query-engine/connector-test-kit-rs/query-engine-tests/tests/new/regressions/mod.rs @@ -27,3 +27,4 @@ mod prisma_7010; mod prisma_7072; mod prisma_7434; mod prisma_8265; +mod prisma_engines_4286; diff --git a/query-engine/connector-test-kit-rs/query-engine-tests/tests/new/regressions/prisma_engines_4286.rs b/query-engine/connector-test-kit-rs/query-engine-tests/tests/new/regressions/prisma_engines_4286.rs new file mode 100644 index 00000000000..313a29cdacf --- /dev/null +++ b/query-engine/connector-test-kit-rs/query-engine-tests/tests/new/regressions/prisma_engines_4286.rs @@ -0,0 +1,24 @@ +use query_engine_tests::*; + +#[test_suite(schema(generic), only(Sqlite("libsql.js")))] +mod sqlite { + #[connector_test] + async fn close_tx_on_error(runner: Runner) -> TestResult<()> { + // Try to open a transaction with unsupported isolation error in SQLite. + let result = runner.start_tx(2000, 5000, Some("ReadUncommitted".to_owned())).await; + assert!(result.is_err()); + + // Without the changes from https://github.com/prisma/prisma-engines/pull/4286 or + // https://github.com/prisma/prisma-engines/pull/4489 this second `start_tx` call will + // either hang infinitely with libSQL driver adapter, or fail with a "cannot start a + // transaction within a transaction" error. + // A more future proof way to check this would be to make both transactions EXCLUSIVE or + // IMMEDIATE if we had control over SQLite transaction type here, as that would not rely on + // both transactions using the same connection if we were to pool multiple SQLite + // connections in the future. + let tx = runner.start_tx(2000, 5000, None).await?; + runner.rollback_tx(tx).await?.unwrap(); + + Ok(()) + } +} diff --git a/query-engine/connector-test-kit-rs/query-engine-tests/tests/queries/aggregation/group_by.rs b/query-engine/connector-test-kit-rs/query-engine-tests/tests/queries/aggregation/group_by.rs index 5abbbfe4bdf..e372c4525f0 100644 --- a/query-engine/connector-test-kit-rs/query-engine-tests/tests/queries/aggregation/group_by.rs +++ b/query-engine/connector-test-kit-rs/query-engine-tests/tests/queries/aggregation/group_by.rs @@ -515,6 +515,54 @@ mod aggregation_group_by { Ok(()) } + fn schema_21789() -> String { + let schema = indoc! { + r#"model Test { + #id(id, Int, @id) + group Int + color Color + } + + enum Color { + blue + red + green + } + "# + }; + + schema.to_owned() + } + + // regression test for https://github.com/prisma/prisma/issues/21789 + #[connector_test(schema(schema_21789), only(Postgres, CockroachDB))] + async fn regression_21789(runner: Runner) -> TestResult<()> { + run_query!( + &runner, + r#"mutation { createOneTest(data: { id: 1, group: 1, color: "red" }) { id } }"# + ); + run_query!( + &runner, + r#"mutation { createOneTest(data: { id: 2, group: 2, color: "green" }) { id } }"# + ); + run_query!( + &runner, + r#"mutation { createOneTest(data: { id: 3, group: 1, color: "blue" }) { id } }"# + ); + + insta::assert_snapshot!( + run_query!(&runner, r#"{ aggregateTest { _max { color } _min { color } } }"#), + @r###"{"data":{"aggregateTest":{"_max":{"color":"green"},"_min":{"color":"blue"}}}}"### + ); + + insta::assert_snapshot!( + run_query!(&runner, r#"{ groupByTest(by: [group], orderBy: { group: asc }) { group _max { color } _min { color } } }"#), + @r###"{"data":{"groupByTest":[{"group":1,"_max":{"color":"red"},"_min":{"color":"blue"}},{"group":2,"_max":{"color":"green"},"_min":{"color":"green"}}]}}"### + ); + + Ok(()) + } + /// Error cases #[connector_test] diff --git a/query-engine/connector-test-kit-rs/query-tests-setup/Cargo.toml b/query-engine/connector-test-kit-rs/query-tests-setup/Cargo.toml index f257d9e5216..cf1b98b25ad 100644 --- a/query-engine/connector-test-kit-rs/query-tests-setup/Cargo.toml +++ b/query-engine/connector-test-kit-rs/query-tests-setup/Cargo.toml @@ -5,7 +5,7 @@ edition = "2021" [dependencies] serde_json.workspace = true -prisma-models = { path = "../../prisma-models" } +query-structure = { path = "../../query-structure" } once_cell = "1" qe-setup = { path = "../qe-setup" } request-handlers = { path = "../../request-handlers" } diff --git a/query-engine/connector-test-kit-rs/query-tests-setup/src/runner/json_adapter/request.rs b/query-engine/connector-test-kit-rs/query-tests-setup/src/runner/json_adapter/request.rs index 0eee2d9e6cb..b9354056b69 100644 --- a/query-engine/connector-test-kit-rs/query-tests-setup/src/runner/json_adapter/request.rs +++ b/query-engine/connector-test-kit-rs/query-tests-setup/src/runner/json_adapter/request.rs @@ -1,7 +1,6 @@ use crate::{TestError, TestResult}; use indexmap::IndexMap; use itertools::Itertools; -use prisma_models::PrismaValue; use query_core::{ constants::custom_types, schema::{ @@ -10,6 +9,7 @@ use query_core::{ }, ArgumentValue, ArgumentValueObject, Selection, }; +use query_structure::PrismaValue; use request_handlers::{Action, FieldQuery, GraphQLProtocolAdapter, JsonSingleQuery, SelectionSet, SelectionSetValue}; use serde_json::{json, Value as JsonValue}; diff --git a/query-engine/connector-test-kit-rs/query-tests-setup/src/runner/json_adapter/response.rs b/query-engine/connector-test-kit-rs/query-tests-setup/src/runner/json_adapter/response.rs index 29029e3cf81..a366fb6bdc1 100644 --- a/query-engine/connector-test-kit-rs/query-tests-setup/src/runner/json_adapter/response.rs +++ b/query-engine/connector-test-kit-rs/query-tests-setup/src/runner/json_adapter/response.rs @@ -1,8 +1,8 @@ -use prisma_models::PrismaValue; use query_core::{ constants::custom_types, response_ir::{Item, ItemRef, Map}, }; +use query_structure::PrismaValue; use request_handlers::{GQLBatchResponse, GQLResponse, PrismaResponse}; pub struct JsonResponse; diff --git a/query-engine/connectors/mongodb-query-connector/Cargo.toml b/query-engine/connectors/mongodb-query-connector/Cargo.toml index c4a02eaa864..b451e17f6e6 100644 --- a/query-engine/connectors/mongodb-query-connector/Cargo.toml +++ b/query-engine/connectors/mongodb-query-connector/Cargo.toml @@ -24,8 +24,8 @@ indexmap = "1.7" query-engine-metrics = {path = "../../metrics"} cuid = { git = "https://github.com/prisma/cuid-rust", branch = "wasm32-support" } -[dependencies.prisma-models] -path = "../../prisma-models" +[dependencies.query-structure] +path = "../../query-structure" [dependencies.mongodb-client] path = "../../../libs/mongodb-client" diff --git a/query-engine/connectors/mongodb-query-connector/src/cursor.rs b/query-engine/connectors/mongodb-query-connector/src/cursor.rs index 9adbf8c1966..1aaa22ef6b1 100644 --- a/query-engine/connectors/mongodb-query-connector/src/cursor.rs +++ b/query-engine/connectors/mongodb-query-connector/src/cursor.rs @@ -1,6 +1,6 @@ use crate::{orderby::OrderByData, IntoBson}; use mongodb::bson::{doc, Document}; -use prisma_models::{OrderBy, SelectionResult, SortOrder}; +use query_structure::{OrderBy, SelectionResult, SortOrder}; #[derive(Debug, Clone)] pub(crate) struct CursorData { diff --git a/query-engine/connectors/mongodb-query-connector/src/error.rs b/query-engine/connectors/mongodb-query-connector/src/error.rs index d71f39fb54e..f32ff78e29c 100644 --- a/query-engine/connectors/mongodb-query-connector/src/error.rs +++ b/query-engine/connectors/mongodb-query-connector/src/error.rs @@ -4,7 +4,7 @@ use mongodb::{ bson::{self, extjson}, error::{CommandError, Error as DriverError, TRANSIENT_TRANSACTION_ERROR}, }; -use prisma_models::{CompositeFieldRef, Field, ScalarFieldRef, SelectedField}; +use query_structure::{CompositeFieldRef, Field, ScalarFieldRef, SelectedField}; use regex::Regex; use thiserror::Error; use user_facing_errors::query_engine::DatabaseConstraint; diff --git a/query-engine/connectors/mongodb-query-connector/src/filter.rs b/query-engine/connectors/mongodb-query-connector/src/filter.rs index 44ca06cf875..64bdadafd6a 100644 --- a/query-engine/connectors/mongodb-query-connector/src/filter.rs +++ b/query-engine/connectors/mongodb-query-connector/src/filter.rs @@ -1,11 +1,6 @@ use crate::{constants::group_by, error::MongoError, join::JoinStage, query_builder::AggregationType, IntoBson}; -use connector_interface::{ - AggregationFilter, CompositeCondition, CompositeFilter, ConditionListValue, ConditionValue, Filter, - OneRelationIsNullFilter, QueryMode, RelationFilter, ScalarCompare, ScalarCondition, ScalarFilter, ScalarListFilter, - ScalarProjection, -}; use mongodb::bson::{doc, Bson, Document}; -use prisma_models::{CompositeFieldRef, PrismaValue, ScalarFieldRef, TypeIdentifier}; +use query_structure::*; #[derive(Debug, Clone)] pub(crate) enum MongoFilter { @@ -132,9 +127,9 @@ impl MongoFilterVisitor { fn visit_scalar_filter(&self, filter: ScalarFilter) -> crate::Result { let field = match filter.projection { - connector_interface::ScalarProjection::Single(sf) => sf, - connector_interface::ScalarProjection::Compound(mut c) if c.len() == 1 => c.pop().unwrap(), - connector_interface::ScalarProjection::Compound(_) => { + ScalarProjection::Single(sf) => sf, + ScalarProjection::Compound(mut c) if c.len() == 1 => c.pop().unwrap(), + ScalarProjection::Compound(_) => { unreachable!( "Multi-field compound filter case hit when it should have been folded into normal filters previously." ) @@ -417,7 +412,7 @@ impl MongoFilterVisitor { let field_ref = filter.as_field_ref().cloned(); let filter_doc = match filter.condition { - connector_interface::ScalarListCondition::Contains(val) => { + ScalarListCondition::Contains(val) => { let bson = match val { ConditionValue::Value(value) => (field, value).into_bson()?, ConditionValue::FieldRef(field_ref) => self.prefixed_field_ref(&field_ref)?, @@ -426,11 +421,11 @@ impl MongoFilterVisitor { doc! { "$in": [bson, coerce_as_array(&field_name)] } } - connector_interface::ScalarListCondition::ContainsEvery(vals) if vals.is_empty() => { + ScalarListCondition::ContainsEvery(vals) if vals.is_empty() => { // Empty hasEvery: Return all records. render_stub_condition(true) } - connector_interface::ScalarListCondition::ContainsEvery(ConditionListValue::List(vals)) => { + ScalarListCondition::ContainsEvery(ConditionListValue::List(vals)) => { let ins = vals .into_iter() .map(|val| { @@ -442,20 +437,18 @@ impl MongoFilterVisitor { doc! { "$and": ins } } - connector_interface::ScalarListCondition::ContainsEvery(ConditionListValue::FieldRef(field_ref)) => { - render_every( - &field_name, - "elem", - doc! { "$in": ["$$elem", coerce_as_array((self.prefix(), &field_ref).into_bson()?)] }, - true, - ) - } + ScalarListCondition::ContainsEvery(ConditionListValue::FieldRef(field_ref)) => render_every( + &field_name, + "elem", + doc! { "$in": ["$$elem", coerce_as_array((self.prefix(), &field_ref).into_bson()?)] }, + true, + ), - connector_interface::ScalarListCondition::ContainsSome(vals) if vals.is_empty() => { + ScalarListCondition::ContainsSome(vals) if vals.is_empty() => { // Empty hasSome: Return no records. render_stub_condition(false) } - connector_interface::ScalarListCondition::ContainsSome(ConditionListValue::List(vals)) => { + ScalarListCondition::ContainsSome(ConditionListValue::List(vals)) => { let ins = vals .into_iter() .map(|val| { @@ -467,19 +460,17 @@ impl MongoFilterVisitor { doc! { "$or": ins } } - connector_interface::ScalarListCondition::ContainsSome(ConditionListValue::FieldRef(field_ref)) => { - render_some( - &field_name, - "elem", - doc! { "$in": ["$$elem", coerce_as_array((self.prefix(), &field_ref).into_bson()?)] }, - true, - ) - } + ScalarListCondition::ContainsSome(ConditionListValue::FieldRef(field_ref)) => render_some( + &field_name, + "elem", + doc! { "$in": ["$$elem", coerce_as_array((self.prefix(), &field_ref).into_bson()?)] }, + true, + ), - connector_interface::ScalarListCondition::IsEmpty(true) => { + ScalarListCondition::IsEmpty(true) => { doc! { "$eq": [render_size(&field_name, true), 0] } } - connector_interface::ScalarListCondition::IsEmpty(false) => { + ScalarListCondition::IsEmpty(false) => { doc! { "$gt": [render_size(&field_name, true), 0] } } }; @@ -653,21 +644,21 @@ impl MongoFilterVisitor { let mut join_stage = JoinStage::new(from_field); let filter_doc = match filter.condition { - connector_interface::RelationCondition::EveryRelatedRecord => { + RelationCondition::EveryRelatedRecord => { let (every, nested_joins) = render_every_from_filter(&field_name, nested_filter, false, false)?; join_stage.extend_nested(nested_joins); every } - connector_interface::RelationCondition::AtLeastOneRelatedRecord => { + RelationCondition::AtLeastOneRelatedRecord => { let (some, nested_joins) = render_some_from_filter(&field_name, nested_filter, false, false)?; join_stage.extend_nested(nested_joins); some } - connector_interface::RelationCondition::NoRelatedRecord if is_to_one => { + RelationCondition::NoRelatedRecord if is_to_one => { if is_empty_filter { // Doesn't need coercing the array since joins always return arrays doc! { "$eq": [render_size(&field_name, false), 0] } @@ -688,7 +679,7 @@ impl MongoFilterVisitor { } } } - connector_interface::RelationCondition::NoRelatedRecord => { + RelationCondition::NoRelatedRecord => { if is_empty_filter { // Doesn't need coercing the array since joins always return arrays doc! { "$eq": [render_size(&field_name, false), 0] } @@ -700,7 +691,7 @@ impl MongoFilterVisitor { none } } - connector_interface::RelationCondition::ToOneRelatedRecord => { + RelationCondition::ToOneRelatedRecord => { // To-ones are coerced to single-element arrays via the join. // We render an "every" expression on that array to ensure that the predicate is matched. let (every, nested_joins) = render_every_from_filter(&field_name, nested_filter, false, false)?; diff --git a/query-engine/connectors/mongodb-query-connector/src/interface/connection.rs b/query-engine/connectors/mongodb-query-connector/src/interface/connection.rs index fc2c241e357..e10c0e1f5b3 100644 --- a/query-engine/connectors/mongodb-query-connector/src/interface/connection.rs +++ b/query-engine/connectors/mongodb-query-connector/src/interface/connection.rs @@ -10,7 +10,7 @@ use connector_interface::{ WriteOperations, }; use mongodb::{ClientSession, Database}; -use prisma_models::{prelude::*, SelectionResult}; +use query_structure::{prelude::*, SelectionResult}; use std::collections::HashMap; pub struct MongoDbConnection { @@ -187,7 +187,7 @@ impl ReadOperations for MongoDbConnection { async fn get_single_record( &mut self, model: &Model, - filter: &connector_interface::Filter, + filter: &query_structure::Filter, selected_fields: &FieldSelection, aggr_selections: &[RelAggregationSelection], _trace_id: Option, @@ -209,7 +209,7 @@ impl ReadOperations for MongoDbConnection { async fn get_many_records( &mut self, model: &Model, - query_arguments: connector_interface::QueryArguments, + query_arguments: query_structure::QueryArguments, selected_fields: &FieldSelection, aggregation_selections: &[RelAggregationSelection], _trace_id: Option, @@ -243,10 +243,10 @@ impl ReadOperations for MongoDbConnection { async fn aggregate_records( &mut self, model: &Model, - query_arguments: connector_interface::QueryArguments, + query_arguments: query_structure::QueryArguments, selections: Vec, group_by: Vec, - having: Option, + having: Option, _trace_id: Option, ) -> connector_interface::Result> { catch(async move { diff --git a/query-engine/connectors/mongodb-query-connector/src/interface/mod.rs b/query-engine/connectors/mongodb-query-connector/src/interface/mod.rs index 5b5821410c9..620d7628182 100644 --- a/query-engine/connectors/mongodb-query-connector/src/interface/mod.rs +++ b/query-engine/connectors/mongodb-query-connector/src/interface/mod.rs @@ -12,8 +12,8 @@ use connector_interface::{ }; use futures::Future; use mongodb::Client; -use prisma_models::prelude::*; use psl::Datasource; +use query_structure::prelude::*; use crate::error::MongoError; diff --git a/query-engine/connectors/mongodb-query-connector/src/interface/transaction.rs b/query-engine/connectors/mongodb-query-connector/src/interface/transaction.rs index 5f7c143c442..1de0bb8c750 100644 --- a/query-engine/connectors/mongodb-query-connector/src/interface/transaction.rs +++ b/query-engine/connectors/mongodb-query-connector/src/interface/transaction.rs @@ -7,8 +7,8 @@ use connector_interface::{ ConnectionLike, ReadOperations, RelAggregationSelection, Transaction, UpdateType, WriteOperations, }; use mongodb::options::{Acknowledgment, ReadConcern, TransactionOptions, WriteConcern}; -use prisma_models::SelectionResult; use query_engine_metrics::{decrement_gauge, increment_gauge, metrics, PRISMA_CLIENT_QUERIES_ACTIVE}; +use query_structure::SelectionResult; use std::collections::HashMap; pub struct MongoDbTransaction<'conn> { @@ -252,7 +252,7 @@ impl<'conn> ReadOperations for MongoDbTransaction<'conn> { async fn get_single_record( &mut self, model: &Model, - filter: &connector_interface::Filter, + filter: &query_structure::Filter, selected_fields: &FieldSelection, aggr_selections: &[RelAggregationSelection], _trace_id: Option, @@ -274,7 +274,7 @@ impl<'conn> ReadOperations for MongoDbTransaction<'conn> { async fn get_many_records( &mut self, model: &Model, - query_arguments: connector_interface::QueryArguments, + query_arguments: query_structure::QueryArguments, selected_fields: &FieldSelection, aggregation_selections: &[RelAggregationSelection], _trace_id: Option, @@ -314,10 +314,10 @@ impl<'conn> ReadOperations for MongoDbTransaction<'conn> { async fn aggregate_records( &mut self, model: &Model, - query_arguments: connector_interface::QueryArguments, + query_arguments: query_structure::QueryArguments, selections: Vec, group_by: Vec, - having: Option, + having: Option, _trace_id: Option, ) -> connector_interface::Result> { catch(async move { diff --git a/query-engine/connectors/mongodb-query-connector/src/join.rs b/query-engine/connectors/mongodb-query-connector/src/join.rs index fb5c46d6858..24c8abe2fba 100644 --- a/query-engine/connectors/mongodb-query-connector/src/join.rs +++ b/query-engine/connectors/mongodb-query-connector/src/join.rs @@ -1,6 +1,6 @@ use crate::filter::MongoFilter; use mongodb::bson::{doc, Document}; -use prisma_models::{walkers, RelationFieldRef, ScalarFieldRef}; +use query_structure::{walkers, RelationFieldRef, ScalarFieldRef}; /// A join stage describes a tree of joins and nested joins to be performed on a collection. /// Every document of the `source` side will be joined with the collection documents diff --git a/query-engine/connectors/mongodb-query-connector/src/orderby.rs b/query-engine/connectors/mongodb-query-connector/src/orderby.rs index 2e89d4399b4..15b37691ed2 100644 --- a/query-engine/connectors/mongodb-query-connector/src/orderby.rs +++ b/query-engine/connectors/mongodb-query-connector/src/orderby.rs @@ -1,7 +1,7 @@ use crate::join::JoinStage; use itertools::Itertools; use mongodb::bson::{doc, Document}; -use prisma_models::{OrderBy, OrderByHop, OrderByToManyAggregation, SortOrder}; +use query_structure::{OrderBy, OrderByHop, OrderByToManyAggregation, SortOrder}; use std::iter; #[derive(Debug)] @@ -230,11 +230,11 @@ impl OrderByBuilder { // Can only be scalar aggregations for groupBy, ToMany aggregations are not supported yet. if let OrderBy::ScalarAggregation(order_by_aggr) = &data.order_by { let prefix = match order_by_aggr.sort_aggregation { - prisma_models::SortAggregation::Count => "count", - prisma_models::SortAggregation::Avg => "avg", - prisma_models::SortAggregation::Sum => "sum", - prisma_models::SortAggregation::Min => "min", - prisma_models::SortAggregation::Max => "max", + query_structure::SortAggregation::Count => "count", + query_structure::SortAggregation::Avg => "avg", + query_structure::SortAggregation::Sum => "sum", + query_structure::SortAggregation::Min => "min", + query_structure::SortAggregation::Max => "max", }; format!("{}_{}", prefix, data.scalar_field_name()) @@ -258,7 +258,7 @@ impl OrderByBuilder { if let OrderBy::ToManyAggregation(order_by_aggregate) = &data.order_by { if !order_by_aggregate.path.is_empty() { match order_by_aggregate.sort_aggregation { - prisma_models::SortAggregation::Count => { + query_structure::SortAggregation::Count => { if let Some(clone_to) = data.prefix.as_ref().and_then(|x| x.clone_to.clone()) { order_aggregate_proj_doc.push(doc! { "$addFields": { clone_to.clone(): { "$size": { "$ifNull": [format!("${}", data.full_reference_path(false)), []] } } } }); field_name = clone_to; // Todo: Just a hack right now, this whole function needs love. diff --git a/query-engine/connectors/mongodb-query-connector/src/output_meta.rs b/query-engine/connectors/mongodb-query-connector/src/output_meta.rs index 3e847477677..081672f9d6e 100644 --- a/query-engine/connectors/mongodb-query-connector/src/output_meta.rs +++ b/query-engine/connectors/mongodb-query-connector/src/output_meta.rs @@ -1,6 +1,6 @@ use connector_interface::{AggregationSelection, RelAggregationSelection}; use indexmap::IndexMap; -use prisma_models::{ +use query_structure::{ ast::FieldArity, DefaultKind, FieldSelection, PrismaValue, ScalarFieldRef, SelectedField, TypeIdentifier, }; diff --git a/query-engine/connectors/mongodb-query-connector/src/projection.rs b/query-engine/connectors/mongodb-query-connector/src/projection.rs index 4ed83cd1452..80a6a3e792e 100644 --- a/query-engine/connectors/mongodb-query-connector/src/projection.rs +++ b/query-engine/connectors/mongodb-query-connector/src/projection.rs @@ -1,6 +1,6 @@ use crate::IntoBson; use mongodb::bson::{Bson, Document}; -use prisma_models::{FieldSelection, SelectedField}; +use query_structure::{FieldSelection, SelectedField}; /// Used as projection document for Mongo queries. impl IntoBson for FieldSelection { @@ -15,13 +15,13 @@ impl IntoBson for FieldSelection { fn path_prefixed_selection(doc: &mut Document, parent_paths: Vec, selections: Vec) { for field in selections { match field { - prisma_models::SelectedField::Scalar(sf) => { + query_structure::SelectedField::Scalar(sf) => { let mut parent_paths = parent_paths.clone(); parent_paths.push(sf.db_name().to_owned()); doc.insert(parent_paths.join("."), Bson::Int32(1)); } - prisma_models::SelectedField::Composite(cs) => { + query_structure::SelectedField::Composite(cs) => { let mut parent_paths = parent_paths.clone(); parent_paths.push(cs.field.db_name().to_owned()); path_prefixed_selection(doc, parent_paths, cs.selections); diff --git a/query-engine/connectors/mongodb-query-connector/src/query_builder/group_by_builder.rs b/query-engine/connectors/mongodb-query-connector/src/query_builder/group_by_builder.rs index 4ea3d459044..f5ac3659f1b 100644 --- a/query-engine/connectors/mongodb-query-connector/src/query_builder/group_by_builder.rs +++ b/query-engine/connectors/mongodb-query-connector/src/query_builder/group_by_builder.rs @@ -1,8 +1,8 @@ use crate::constants::*; -use connector_interface::{AggregationSelection, Filter}; +use connector_interface::AggregationSelection; use mongodb::bson::{doc, Bson, Document}; -use prisma_models::ScalarFieldRef; +use query_structure::{AggregationFilter, Filter, ScalarFieldRef}; use std::collections::HashSet; /// Represents a `$group` aggregation stage. @@ -161,19 +161,19 @@ impl GroupByBuilder { unfold_filters(filters); } Filter::Aggregation(aggregation) => match aggregation { - connector_interface::AggregationFilter::Count(filter) => { + AggregationFilter::Count(filter) => { self.insert_from_filter(filter.as_ref(), AggregationType::Count); } - connector_interface::AggregationFilter::Average(filter) => { + AggregationFilter::Average(filter) => { self.insert_from_filter(filter.as_ref(), AggregationType::Average); } - connector_interface::AggregationFilter::Sum(filter) => { + AggregationFilter::Sum(filter) => { self.insert_from_filter(filter.as_ref(), AggregationType::Sum); } - connector_interface::AggregationFilter::Min(filter) => { + AggregationFilter::Min(filter) => { self.insert_from_filter(filter.as_ref(), AggregationType::Min); } - connector_interface::AggregationFilter::Max(filter) => { + AggregationFilter::Max(filter) => { self.insert_from_filter(filter.as_ref(), AggregationType::Max); } }, diff --git a/query-engine/connectors/mongodb-query-connector/src/query_builder/read_query_builder.rs b/query-engine/connectors/mongodb-query-connector/src/query_builder/read_query_builder.rs index e6ca5492998..fcf749fc2d3 100644 --- a/query-engine/connectors/mongodb-query-connector/src/query_builder/read_query_builder.rs +++ b/query-engine/connectors/mongodb-query-connector/src/query_builder/read_query_builder.rs @@ -10,14 +10,14 @@ use crate::{ root_queries::observing, vacuum_cursor, BsonTransform, IntoBson, }; -use connector_interface::{AggregationSelection, Filter, QueryArguments, RelAggregationSelection}; +use connector_interface::{AggregationSelection, RelAggregationSelection}; use itertools::Itertools; use mongodb::{ bson::{doc, Document}, options::AggregateOptions, ClientSession, Collection, }; -use prisma_models::{FieldSelection, Model, ScalarFieldRef}; +use query_structure::{FieldSelection, Filter, Model, QueryArguments, ScalarFieldRef}; use std::convert::TryFrom; // Mongo Driver broke usage of the simple API, can't be used by us anymore. diff --git a/query-engine/connectors/mongodb-query-connector/src/root_queries/aggregate.rs b/query-engine/connectors/mongodb-query-connector/src/root_queries/aggregate.rs index 65ee8a71ae3..05ff57053e9 100644 --- a/query-engine/connectors/mongodb-query-connector/src/root_queries/aggregate.rs +++ b/query-engine/connectors/mongodb-query-connector/src/root_queries/aggregate.rs @@ -2,7 +2,7 @@ use crate::{constants::*, output_meta, query_builder::MongoReadQueryBuilder, val use connector_interface::*; use mongodb::{bson::Document, ClientSession, Database}; -use prisma_models::prelude::*; +use query_structure::{prelude::*, Filter, QueryArguments}; pub async fn aggregate<'conn>( database: &Database, diff --git a/query-engine/connectors/mongodb-query-connector/src/root_queries/mod.rs b/query-engine/connectors/mongodb-query-connector/src/root_queries/mod.rs index ba1257270da..f66adbac3e3 100644 --- a/query-engine/connectors/mongodb-query-connector/src/root_queries/mod.rs +++ b/query-engine/connectors/mongodb-query-connector/src/root_queries/mod.rs @@ -13,11 +13,11 @@ use crate::{ use futures::Future; use mongodb::bson::Bson; use mongodb::bson::Document; -use prisma_models::*; use query_engine_metrics::{ histogram, increment_counter, metrics, PRISMA_DATASOURCE_QUERIES_DURATION_HISTOGRAM_MS, PRISMA_DATASOURCE_QUERIES_TOTAL, }; +use query_structure::*; use std::time::Instant; use tracing::debug; diff --git a/query-engine/connectors/mongodb-query-connector/src/root_queries/raw.rs b/query-engine/connectors/mongodb-query-connector/src/root_queries/raw.rs index 6876ab68333..f674eafe9fd 100644 --- a/query-engine/connectors/mongodb-query-connector/src/root_queries/raw.rs +++ b/query-engine/connectors/mongodb-query-connector/src/root_queries/raw.rs @@ -4,7 +4,7 @@ use mongodb::{ bson::{from_bson, Bson, Document}, options::*, }; -use prisma_models::{Model, PrismaValue}; +use query_structure::{Model, PrismaValue}; use std::collections::HashMap; #[allow(clippy::large_enum_variant)] diff --git a/query-engine/connectors/mongodb-query-connector/src/root_queries/read.rs b/query-engine/connectors/mongodb-query-connector/src/root_queries/read.rs index 58bf634c4c0..0d9ac09ae26 100644 --- a/query-engine/connectors/mongodb-query-connector/src/root_queries/read.rs +++ b/query-engine/connectors/mongodb-query-connector/src/root_queries/read.rs @@ -3,9 +3,9 @@ use crate::{ error::DecorateErrorWithFieldInformationExtension, output_meta, query_builder::MongoReadQueryBuilder, vacuum_cursor, IntoBson, }; -use connector_interface::{Filter, QueryArguments, RelAggregationSelection}; +use connector_interface::RelAggregationSelection; use mongodb::{bson::doc, options::FindOptions, ClientSession, Database}; -use prisma_models::*; +use query_structure::*; use tracing::{info_span, Instrument}; /// Finds a single record. Joins are not required at the moment because the selector is always a unique one. diff --git a/query-engine/connectors/mongodb-query-connector/src/root_queries/update/into_operation.rs b/query-engine/connectors/mongodb-query-connector/src/root_queries/update/into_operation.rs index 3f18d835193..01ff5abcbd1 100644 --- a/query-engine/connectors/mongodb-query-connector/src/root_queries/update/into_operation.rs +++ b/query-engine/connectors/mongodb-query-connector/src/root_queries/update/into_operation.rs @@ -3,7 +3,7 @@ use crate::*; use connector_interface::{CompositeWriteOperation, FieldPath, ScalarWriteOperation, WriteOperation}; use mongodb::bson::doc; -use prisma_models::{Field, PrismaValue}; +use query_structure::{Field, PrismaValue}; pub(crate) trait IntoUpdateOperation { fn into_update_operations(self, field: &Field, path: FieldPath) -> crate::Result>; diff --git a/query-engine/connectors/mongodb-query-connector/src/root_queries/update/operation.rs b/query-engine/connectors/mongodb-query-connector/src/root_queries/update/operation.rs index cdb7be2c601..0fa814d81af 100644 --- a/query-engine/connectors/mongodb-query-connector/src/root_queries/update/operation.rs +++ b/query-engine/connectors/mongodb-query-connector/src/root_queries/update/operation.rs @@ -1,6 +1,7 @@ use super::{expression, into_expression::IntoUpdateExpression}; -use connector_interface::{FieldPath, Filter}; +use connector_interface::FieldPath; use mongodb::bson::{doc, Document}; +use query_structure::Filter; /// `UpdateOperation` is an intermediary AST used to perform preliminary transformations from a `WriteOperation`. /// It is meant to be transformed into an `UpdateExpression`. diff --git a/query-engine/connectors/mongodb-query-connector/src/root_queries/write.rs b/query-engine/connectors/mongodb-query-connector/src/root_queries/write.rs index f5aa24c6b5d..c0c43f108ae 100644 --- a/query-engine/connectors/mongodb-query-connector/src/root_queries/write.rs +++ b/query-engine/connectors/mongodb-query-connector/src/root_queries/write.rs @@ -15,7 +15,7 @@ use mongodb::{ options::InsertManyOptions, ClientSession, Collection, Database, }; -use prisma_models::{Model, PrismaValue, SelectionResult}; +use query_structure::{Model, PrismaValue, SelectionResult}; use std::{collections::HashMap, convert::TryInto}; use tracing::{info_span, Instrument}; use update::IntoUpdateDocumentExtension; diff --git a/query-engine/connectors/mongodb-query-connector/src/value.rs b/query-engine/connectors/mongodb-query-connector/src/value.rs index cf984ad7683..cf6812d59b6 100644 --- a/query-engine/connectors/mongodb-query-connector/src/value.rs +++ b/query-engine/connectors/mongodb-query-connector/src/value.rs @@ -7,10 +7,10 @@ use bigdecimal::{BigDecimal, FromPrimitive, ToPrimitive}; use chrono::{TimeZone, Utc}; use itertools::Itertools; use mongodb::bson::{oid::ObjectId, spec::BinarySubtype, Binary, Bson, Document, Timestamp}; -use prisma_models::{ +use psl::builtin_connectors::MongoDbType; +use query_structure::{ CompositeFieldRef, Field, PrismaValue, RelationFieldRef, ScalarFieldRef, SelectedField, TypeIdentifier, }; -use psl::builtin_connectors::MongoDbType; use serde_json::Value; use std::{convert::TryFrom, fmt::Display}; diff --git a/query-engine/connectors/query-connector/Cargo.toml b/query-engine/connectors/query-connector/Cargo.toml index 788b8ca6557..cc99c62d681 100644 --- a/query-engine/connectors/query-connector/Cargo.toml +++ b/query-engine/connectors/query-connector/Cargo.toml @@ -9,7 +9,7 @@ async-trait = "0.1.31" chrono = {version = "0.4", features = ["serde"]} futures = "0.3" itertools = "0.10" -prisma-models = {path = "../../prisma-models"} +query-structure = {path = "../../query-structure"} prisma-value = {path = "../../../libs/prisma-value"} serde.workspace = true serde_json.workspace = true diff --git a/query-engine/connectors/query-connector/src/coerce.rs b/query-engine/connectors/query-connector/src/coerce.rs index 87f04eed4f2..9c09ea5235e 100644 --- a/query-engine/connectors/query-connector/src/coerce.rs +++ b/query-engine/connectors/query-connector/src/coerce.rs @@ -1,4 +1,4 @@ -use prisma_models::PrismaValue; +use query_structure::PrismaValue; pub fn coerce_null_to_zero_value(value: PrismaValue) -> PrismaValue { if let PrismaValue::Null = value { diff --git a/query-engine/connectors/query-connector/src/error.rs b/query-engine/connectors/query-connector/src/error.rs index 96d8d9dcbac..e34b7668a7d 100644 --- a/query-engine/connectors/query-connector/src/error.rs +++ b/query-engine/connectors/query-connector/src/error.rs @@ -1,6 +1,6 @@ -use crate::filter::Filter; use itertools::Itertools; -use prisma_models::prelude::DomainError; +use query_structure::prelude::DomainError; +use query_structure::Filter; use std::fmt::Display; use thiserror::Error; use user_facing_errors::{query_engine::DatabaseConstraint, KnownError}; diff --git a/query-engine/connectors/query-connector/src/interface.rs b/query-engine/connectors/query-connector/src/interface.rs index 80e01578bd0..942edd1868f 100644 --- a/query-engine/connectors/query-connector/src/interface.rs +++ b/query-engine/connectors/query-connector/src/interface.rs @@ -1,7 +1,7 @@ -use crate::{coerce_null_to_zero_value, Filter, NativeUpsert, QueryArguments, WriteArgs}; +use crate::{coerce_null_to_zero_value, NativeUpsert, WriteArgs}; use async_trait::async_trait; -use prisma_models::{ast::FieldArity, *}; use prisma_value::PrismaValue; +use query_structure::{ast::FieldArity, *}; use std::collections::HashMap; #[async_trait] diff --git a/query-engine/connectors/query-connector/src/lib.rs b/query-engine/connectors/query-connector/src/lib.rs index b60554c54b5..5488dfaef49 100644 --- a/query-engine/connectors/query-connector/src/lib.rs +++ b/query-engine/connectors/query-connector/src/lib.rs @@ -1,20 +1,14 @@ #![allow(clippy::derive_partial_eq_without_eq)] pub mod error; -pub mod filter; mod coerce; -mod compare; mod interface; -mod query_arguments; mod upsert; mod write_args; pub use coerce::*; -pub use compare::*; -pub use filter::*; pub use interface::*; -pub use query_arguments::*; pub use upsert::*; pub use write_args::*; diff --git a/query-engine/connectors/query-connector/src/upsert.rs b/query-engine/connectors/query-connector/src/upsert.rs index 87421511de1..9455fbc30c4 100644 --- a/query-engine/connectors/query-connector/src/upsert.rs +++ b/query-engine/connectors/query-connector/src/upsert.rs @@ -1,5 +1,5 @@ -use crate::{Filter, RecordFilter, WriteArgs}; -use prisma_models::{FieldSelection, Model, ScalarFieldRef}; +use crate::{RecordFilter, WriteArgs}; +use query_structure::{FieldSelection, Filter, Model, ScalarFieldRef}; #[derive(Debug, Clone)] pub struct NativeUpsert { diff --git a/query-engine/connectors/query-connector/src/write_args.rs b/query-engine/connectors/query-connector/src/write_args.rs index e75ca288ac0..e0b03097504 100644 --- a/query-engine/connectors/query-connector/src/write_args.rs +++ b/query-engine/connectors/query-connector/src/write_args.rs @@ -1,10 +1,8 @@ -use crate::{ - error::{ConnectorError, ErrorKind}, - Filter, -}; +use crate::error::{ConnectorError, ErrorKind}; use indexmap::{map::Keys, IndexMap}; -use prisma_models::{ - CompositeFieldRef, Field, Model, ModelProjection, PrismaValue, ScalarFieldRef, SelectedField, SelectionResult, +use query_structure::{ + CompositeFieldRef, Field, Filter, Model, ModelProjection, PrismaValue, ScalarFieldRef, SelectedField, + SelectionResult, }; use std::{borrow::Borrow, convert::TryInto, ops::Deref}; diff --git a/query-engine/connectors/sql-query-connector/Cargo.toml b/query-engine/connectors/sql-query-connector/Cargo.toml index 9ed0b407005..fbe04850164 100644 --- a/query-engine/connectors/sql-query-connector/Cargo.toml +++ b/query-engine/connectors/sql-query-connector/Cargo.toml @@ -38,8 +38,8 @@ quaint = { path = "../../../quaint" } package = "query-connector" path = "../query-connector" -[dependencies.prisma-models] -path = "../../prisma-models" +[dependencies.query-structure] +path = "../../query-structure" [dependencies.prisma-value] path = "../../../libs/prisma-value" diff --git a/query-engine/connectors/sql-query-connector/src/column_metadata.rs b/query-engine/connectors/sql-query-connector/src/column_metadata.rs index 7555bbf3331..c64871b7eb2 100644 --- a/query-engine/connectors/sql-query-connector/src/column_metadata.rs +++ b/query-engine/connectors/sql-query-connector/src/column_metadata.rs @@ -1,4 +1,4 @@ -use prisma_models::{FieldArity, TypeIdentifier}; +use query_structure::{FieldArity, TypeIdentifier}; /// Helps dealing with column value conversion and possible error resolution. #[derive(Clone, Debug, Copy)] diff --git a/query-engine/connectors/sql-query-connector/src/cursor_condition.rs b/query-engine/connectors/sql-query-connector/src/cursor_condition.rs index 34373eaf3d5..d34fd49b2a3 100644 --- a/query-engine/connectors/sql-query-connector/src/cursor_condition.rs +++ b/query-engine/connectors/sql-query-connector/src/cursor_condition.rs @@ -5,10 +5,9 @@ use crate::{ query_arguments_ext::QueryArgumentsExt, Context, }; -use connector_interface::QueryArguments; use itertools::Itertools; -use prisma_models::*; use quaint::ast::*; +use query_structure::*; #[derive(Debug)] struct CursorOrderDefinition { diff --git a/query-engine/connectors/sql-query-connector/src/database/connection.rs b/query-engine/connectors/sql-query-connector/src/database/connection.rs index 7895e838399..cb7c0a9b312 100644 --- a/query-engine/connectors/sql-query-connector/src/database/connection.rs +++ b/query-engine/connectors/sql-query-connector/src/database/connection.rs @@ -5,15 +5,15 @@ use crate::{database::operations::*, Context, SqlError}; use async_trait::async_trait; use connector::{ConnectionLike, RelAggregationSelection}; use connector_interface::{ - self as connector, filter::Filter, AggregationRow, AggregationSelection, Connection, QueryArguments, - ReadOperations, RecordFilter, Transaction, WriteArgs, WriteOperations, + self as connector, AggregationRow, AggregationSelection, Connection, ReadOperations, RecordFilter, Transaction, + WriteArgs, WriteOperations, }; -use prisma_models::{prelude::*, SelectionResult}; use prisma_value::PrismaValue; use quaint::{ connector::{IsolationLevel, TransactionCapable}, prelude::{ConnectionInfo, Queryable}, }; +use query_structure::{prelude::*, Filter, QueryArguments, SelectionResult}; use std::{collections::HashMap, str::FromStr}; pub(crate) struct SqlConnection { diff --git a/query-engine/connectors/sql-query-connector/src/database/operations/read.rs b/query-engine/connectors/sql-query-connector/src/database/operations/read.rs index 470628de113..4d33fe3d2ff 100644 --- a/query-engine/connectors/sql-query-connector/src/database/operations/read.rs +++ b/query-engine/connectors/sql-query-connector/src/database/operations/read.rs @@ -7,8 +7,8 @@ use crate::{ }; use connector_interface::*; use futures::stream::{FuturesUnordered, StreamExt}; -use prisma_models::*; use quaint::ast::*; +use query_structure::*; pub(crate) async fn get_single_record( conn: &dyn Queryable, @@ -18,7 +18,13 @@ pub(crate) async fn get_single_record( aggr_selections: &[RelAggregationSelection], ctx: &Context<'_>, ) -> crate::Result> { - let query = read::get_records(model, selected_fields.as_columns(ctx), aggr_selections, filter, ctx); + let query = read::get_records( + model, + selected_fields.as_columns(ctx).mark_all_selected(), + aggr_selections, + filter, + ctx, + ); let mut field_names: Vec<_> = selected_fields.db_names().collect(); let mut aggr_field_names: Vec<_> = aggr_selections.iter().map(|aggr_sel| aggr_sel.db_alias()).collect(); @@ -104,7 +110,13 @@ pub(crate) async fn get_many_records( let mut futures = FuturesUnordered::new(); for args in batches.into_iter() { - let query = read::get_records(model, selected_fields.as_columns(ctx), aggr_selections, args, ctx); + let query = read::get_records( + model, + selected_fields.as_columns(ctx).mark_all_selected(), + aggr_selections, + args, + ctx, + ); futures.push(conn.filter(query.into(), meta.as_slice(), ctx)); } @@ -122,7 +134,7 @@ pub(crate) async fn get_many_records( _ => { let query = read::get_records( model, - selected_fields.as_columns(ctx), + selected_fields.as_columns(ctx).mark_all_selected(), aggr_selections, query_arguments, ctx, diff --git a/query-engine/connectors/sql-query-connector/src/database/operations/update.rs b/query-engine/connectors/sql-query-connector/src/database/operations/update.rs index 2270d6c6fef..617e02455ab 100644 --- a/query-engine/connectors/sql-query-connector/src/database/operations/update.rs +++ b/query-engine/connectors/sql-query-connector/src/database/operations/update.rs @@ -8,7 +8,7 @@ use crate::{Context, QueryExt, Queryable}; use connector_interface::*; use itertools::Itertools; -use prisma_models::*; +use query_structure::*; use std::usize; /// Performs an update with an explicit selection set. diff --git a/query-engine/connectors/sql-query-connector/src/database/operations/upsert.rs b/query-engine/connectors/sql-query-connector/src/database/operations/upsert.rs index cfd473923ff..f086e4c6079 100644 --- a/query-engine/connectors/sql-query-connector/src/database/operations/upsert.rs +++ b/query-engine/connectors/sql-query-connector/src/database/operations/upsert.rs @@ -7,8 +7,8 @@ use crate::{ Context, Queryable, }; use connector_interface::NativeUpsert; -use prisma_models::{ModelProjection, Record, SingleRecord}; use quaint::prelude::{OnConflict, Query}; +use query_structure::{ModelProjection, Record, SingleRecord}; pub(crate) async fn native_upsert( conn: &dyn Queryable, diff --git a/query-engine/connectors/sql-query-connector/src/database/operations/write.rs b/query-engine/connectors/sql-query-connector/src/database/operations/write.rs index 611557c4f3b..3a70539e5dd 100644 --- a/query-engine/connectors/sql-query-connector/src/database/operations/write.rs +++ b/query-engine/connectors/sql-query-connector/src/database/operations/write.rs @@ -8,11 +8,11 @@ use crate::{ }; use connector_interface::*; use itertools::Itertools; -use prisma_models::*; use quaint::{ error::ErrorKind, prelude::{native_uuid, uuid_to_bin, uuid_to_bin_swapped, Aliasable, Select, SqlFamily}, }; +use query_structure::*; use std::{ collections::{HashMap, HashSet}, ops::Deref, diff --git a/query-engine/connectors/sql-query-connector/src/database/transaction.rs b/query-engine/connectors/sql-query-connector/src/database/transaction.rs index 517c293457f..7fa9aaf3b5b 100644 --- a/query-engine/connectors/sql-query-connector/src/database/transaction.rs +++ b/query-engine/connectors/sql-query-connector/src/database/transaction.rs @@ -3,12 +3,12 @@ use crate::{database::operations::*, Context, SqlError}; use async_trait::async_trait; use connector::{ConnectionLike, RelAggregationSelection}; use connector_interface::{ - self as connector, filter::Filter, AggregationRow, AggregationSelection, QueryArguments, ReadOperations, - RecordFilter, Transaction, WriteArgs, WriteOperations, + self as connector, AggregationRow, AggregationSelection, ReadOperations, RecordFilter, Transaction, WriteArgs, + WriteOperations, }; -use prisma_models::{prelude::*, SelectionResult}; use prisma_value::PrismaValue; use quaint::prelude::ConnectionInfo; +use query_structure::{prelude::*, Filter, QueryArguments, SelectionResult}; use std::collections::HashMap; pub struct SqlConnectorTransaction<'tx> { diff --git a/query-engine/connectors/sql-query-connector/src/error.rs b/query-engine/connectors/sql-query-connector/src/error.rs index 9744aa0d5ef..a7770879c51 100644 --- a/query-engine/connectors/sql-query-connector/src/error.rs +++ b/query-engine/connectors/sql-query-connector/src/error.rs @@ -1,6 +1,6 @@ -use connector_interface::{error::*, Filter}; -use prisma_models::prelude::DomainError; +use connector_interface::error::*; use quaint::error::ErrorKind as QuaintKind; +use query_structure::{prelude::DomainError, Filter}; use std::{any::Any, string::FromUtf8Error}; use thiserror::Error; use user_facing_errors::query_engine::DatabaseConstraint; @@ -267,8 +267,8 @@ impl SqlError { } } -impl From for SqlError { - fn from(e: prisma_models::ConversionFailure) -> Self { +impl From for SqlError { + fn from(e: query_structure::ConversionFailure) -> Self { Self::ConversionError(e.into()) } } diff --git a/query-engine/connectors/sql-query-connector/src/filter/alias.rs b/query-engine/connectors/sql-query-connector/src/filter/alias.rs index 61686929d40..c7a62bba02a 100644 --- a/query-engine/connectors/sql-query-connector/src/filter/alias.rs +++ b/query-engine/connectors/sql-query-connector/src/filter/alias.rs @@ -1,7 +1,7 @@ use crate::{model_extensions::AsColumn, *}; -use prisma_models::ScalarField; use quaint::prelude::Column; +use query_structure::ScalarField; #[derive(Clone, Copy, Debug)] /// A distinction in aliasing to separate the parent table and the joined data diff --git a/query-engine/connectors/sql-query-connector/src/filter/mod.rs b/query-engine/connectors/sql-query-connector/src/filter/mod.rs index bbf3557b16b..b9ae856ef65 100644 --- a/query-engine/connectors/sql-query-connector/src/filter/mod.rs +++ b/query-engine/connectors/sql-query-connector/src/filter/mod.rs @@ -1,8 +1,8 @@ mod alias; mod visitor; -use connector_interface::Filter; use quaint::prelude::*; +use query_structure::Filter; use visitor::*; use crate::{context::Context, join_utils::AliasedJoin}; diff --git a/query-engine/connectors/sql-query-connector/src/filter/visitor.rs b/query-engine/connectors/sql-query-connector/src/filter/visitor.rs index 6ab32f89735..1a71cdd824a 100644 --- a/query-engine/connectors/sql-query-connector/src/filter/visitor.rs +++ b/query-engine/connectors/sql-query-connector/src/filter/visitor.rs @@ -2,11 +2,10 @@ use super::alias::*; use crate::join_utils::{compute_one2m_join, AliasedJoin}; use crate::{model_extensions::*, Context}; -use connector_interface::filter::*; -use prisma_models::prelude::*; use psl::datamodel_connector::ConnectorCapability; use quaint::ast::concat; use quaint::ast::*; +use query_structure::{filter::*, prelude::*}; use std::convert::TryInto; pub(crate) trait FilterVisitorExt { diff --git a/query-engine/connectors/sql-query-connector/src/join_utils.rs b/query-engine/connectors/sql-query-connector/src/join_utils.rs index 4b4d2fc8aa2..cedc264f94b 100644 --- a/query-engine/connectors/sql-query-connector/src/join_utils.rs +++ b/query-engine/connectors/sql-query-connector/src/join_utils.rs @@ -1,7 +1,6 @@ use crate::{filter::FilterBuilder, model_extensions::*, Context}; -use connector_interface::Filter; -use prisma_models::*; use quaint::prelude::*; +use query_structure::*; #[derive(Debug, Clone)] pub(crate) struct AliasedJoin { diff --git a/query-engine/connectors/sql-query-connector/src/model_extensions/column.rs b/query-engine/connectors/sql-query-connector/src/model_extensions/column.rs index 445bada9c45..c2eb84435d5 100644 --- a/query-engine/connectors/sql-query-connector/src/model_extensions/column.rs +++ b/query-engine/connectors/sql-query-connector/src/model_extensions/column.rs @@ -1,12 +1,21 @@ use crate::{model_extensions::ScalarFieldExt, Context}; use itertools::Itertools; -use prisma_models::{Field, ModelProjection, RelationField, ScalarField}; use quaint::ast::{Column, Row}; +use query_structure::{Field, ModelProjection, RelationField, ScalarField}; pub struct ColumnIterator { inner: Box> + 'static>, } +impl ColumnIterator { + /// Sets all columns as selected. This is a hack that we use to help the Postgres SQL visitor cast enum columns to text to avoid some driver roundtrips otherwise needed to resolve enum types. + pub fn mark_all_selected(self) -> Self { + ColumnIterator { + inner: Box::new(self.inner.map(|c| c.set_is_selected(true))), + } + } +} + impl Iterator for ColumnIterator { type Item = Column<'static>; diff --git a/query-engine/connectors/sql-query-connector/src/model_extensions/record.rs b/query-engine/connectors/sql-query-connector/src/model_extensions/record.rs index 0204046315a..e764aa8e58b 100644 --- a/query-engine/connectors/sql-query-connector/src/model_extensions/record.rs +++ b/query-engine/connectors/sql-query-connector/src/model_extensions/record.rs @@ -1,6 +1,6 @@ use crate::{value::to_prisma_value, SqlError}; -use prisma_models::{DomainError, ModelProjection, SelectionResult}; use quaint::connector::ResultSet; +use query_structure::{DomainError, ModelProjection, SelectionResult}; pub fn try_convert(model_projection: &ModelProjection, result_set: ResultSet) -> crate::Result { let columns: Vec = result_set.columns().iter().map(|c| c.to_string()).collect(); diff --git a/query-engine/connectors/sql-query-connector/src/model_extensions/relation.rs b/query-engine/connectors/sql-query-connector/src/model_extensions/relation.rs index 6941546c51e..98139053680 100644 --- a/query-engine/connectors/sql-query-connector/src/model_extensions/relation.rs +++ b/query-engine/connectors/sql-query-connector/src/model_extensions/relation.rs @@ -2,8 +2,8 @@ use crate::{ model_extensions::{AsColumns, AsTable, ColumnIterator}, Context, }; -use prisma_models::{walkers, ModelProjection, Relation, RelationField}; use quaint::{ast::Table, prelude::Column}; +use query_structure::{walkers, ModelProjection, Relation, RelationField}; pub(crate) trait RelationFieldExt { fn m2m_columns(&self, ctx: &Context<'_>) -> Vec>; diff --git a/query-engine/connectors/sql-query-connector/src/model_extensions/scalar_field.rs b/query-engine/connectors/sql-query-connector/src/model_extensions/scalar_field.rs index 7eb414dd92a..21612e1a639 100644 --- a/query-engine/connectors/sql-query-connector/src/model_extensions/scalar_field.rs +++ b/query-engine/connectors/sql-query-connector/src/model_extensions/scalar_field.rs @@ -1,11 +1,11 @@ use crate::context::Context; use chrono::Utc; -use prisma_models::{ScalarField, TypeIdentifier}; use prisma_value::PrismaValue; use quaint::{ ast::{EnumName, Value, ValueType}, prelude::{EnumVariant, TypeDataLength, TypeFamily}, }; +use query_structure::{ScalarField, TypeIdentifier}; pub(crate) trait ScalarFieldExt { fn value<'a>(&self, pv: PrismaValue, ctx: &Context<'_>) -> Value<'a>; diff --git a/query-engine/connectors/sql-query-connector/src/model_extensions/selection_result.rs b/query-engine/connectors/sql-query-connector/src/model_extensions/selection_result.rs index 25d994b1d64..51eb7768d06 100644 --- a/query-engine/connectors/sql-query-connector/src/model_extensions/selection_result.rs +++ b/query-engine/connectors/sql-query-connector/src/model_extensions/selection_result.rs @@ -1,7 +1,7 @@ use super::ScalarFieldExt; use crate::context::Context; -use prisma_models::{PrismaValue, SelectedField, SelectionResult}; use quaint::Value; +use query_structure::{PrismaValue, SelectedField, SelectionResult}; pub(crate) trait SelectionResultExt { fn misses_autogen_value(&self) -> bool; diff --git a/query-engine/connectors/sql-query-connector/src/model_extensions/table.rs b/query-engine/connectors/sql-query-connector/src/model_extensions/table.rs index 8217b5e1204..ead15c34658 100644 --- a/query-engine/connectors/sql-query-connector/src/model_extensions/table.rs +++ b/query-engine/connectors/sql-query-connector/src/model_extensions/table.rs @@ -1,6 +1,6 @@ use crate::{model_extensions::AsColumns, Context}; -use prisma_models::Model; use quaint::ast::{Column, Table}; +use query_structure::Model; pub(crate) fn db_name_with_schema(model: &Model, ctx: &Context<'_>) -> Table<'static> { let schema_prefix = model @@ -32,7 +32,7 @@ impl AsTable for Model { self.unique_indexes().fold(table, |table, index| { let fields: Vec<_> = index .fields() - .map(|f| prisma_models::ScalarFieldRef::from((self.dm.clone(), f))) + .map(|f| query_structure::ScalarFieldRef::from((self.dm.clone(), f))) .collect(); let index: Vec> = fields.as_columns(ctx).collect(); table.add_unique_index(index) diff --git a/query-engine/connectors/sql-query-connector/src/ordering.rs b/query-engine/connectors/sql-query-connector/src/ordering.rs index cf49698405e..5f61d0c3a90 100644 --- a/query-engine/connectors/sql-query-connector/src/ordering.rs +++ b/query-engine/connectors/sql-query-connector/src/ordering.rs @@ -1,8 +1,7 @@ use crate::{join_utils::*, model_extensions::*, query_arguments_ext::QueryArgumentsExt, Context}; -use connector_interface::QueryArguments; use itertools::Itertools; -use prisma_models::*; use quaint::ast::*; +use query_structure::*; static ORDER_JOIN_PREFIX: &str = "orderby_"; static ORDER_AGGREGATOR_ALIAS: &str = "orderby_aggregator"; diff --git a/query-engine/connectors/sql-query-connector/src/query_arguments_ext.rs b/query-engine/connectors/sql-query-connector/src/query_arguments_ext.rs index b0319b28b22..414ab7247c6 100644 --- a/query-engine/connectors/sql-query-connector/src/query_arguments_ext.rs +++ b/query-engine/connectors/sql-query-connector/src/query_arguments_ext.rs @@ -1,4 +1,4 @@ -use connector_interface::QueryArguments; +use query_structure::QueryArguments; pub(crate) trait QueryArgumentsExt { /// If we need to take rows before a cursor position, then we need to reverse the order in SQL. diff --git a/query-engine/connectors/sql-query-connector/src/query_builder/mod.rs b/query-engine/connectors/sql-query-connector/src/query_builder/mod.rs index f9a3d43905e..b605d076eed 100644 --- a/query-engine/connectors/sql-query-connector/src/query_builder/mod.rs +++ b/query-engine/connectors/sql-query-connector/src/query_builder/mod.rs @@ -3,8 +3,8 @@ pub(crate) mod write; use crate::context::Context; use crate::model_extensions::SelectionResultExt; -use prisma_models::SelectionResult; use quaint::ast::{Column, Comparable, ConditionTree, Query, Row, Values}; +use query_structure::SelectionResult; const PARAMETER_LIMIT: usize = 2000; diff --git a/query-engine/connectors/sql-query-connector/src/query_builder/read.rs b/query-engine/connectors/sql-query-connector/src/query_builder/read.rs index a5385f1dd56..3aa91288ea9 100644 --- a/query-engine/connectors/sql-query-connector/src/query_builder/read.rs +++ b/query-engine/connectors/sql-query-connector/src/query_builder/read.rs @@ -2,10 +2,10 @@ use crate::{ cursor_condition, filter::FilterBuilder, model_extensions::*, nested_aggregations, ordering::OrderByBuilder, sql_trace::SqlTraceComment, Context, }; -use connector_interface::{filter::Filter, AggregationSelection, QueryArguments, RelAggregationSelection}; +use connector_interface::{AggregationSelection, RelAggregationSelection}; use itertools::Itertools; -use prisma_models::*; use quaint::ast::*; +use query_structure::*; use tracing::Span; pub(crate) trait SelectDefinition { @@ -124,9 +124,7 @@ where T: SelectDefinition, { let (select, additional_selection_set) = query.into_select(model, aggr_selections, ctx); - let select = columns - .map(|c| c.set_is_selected(true)) - .fold(select, |acc, col| acc.column(col)); + let select = columns.fold(select, |acc, col| acc.column(col)); let select = select.append_trace(&Span::current()).add_trace_id(ctx.trace_id); @@ -176,7 +174,11 @@ pub(crate) fn aggregate( .append_trace(&Span::current()) .add_trace_id(ctx.trace_id), |select, next_op| match next_op { - AggregationSelection::Field(field) => select.column(Column::from(field.db_name().to_owned())), + AggregationSelection::Field(field) => select.column( + Column::from(field.db_name().to_owned()) + .set_is_enum(field.type_identifier().is_enum()) + .set_is_selected(true), + ), AggregationSelection::Count { all, fields } => { let select = fields.iter().fold(select, |select, next_field| { @@ -199,11 +201,15 @@ pub(crate) fn aggregate( }), AggregationSelection::Min(fields) => fields.iter().fold(select, |select, next_field| { - select.value(min(Column::from(next_field.db_name().to_owned()))) + select.value(min(Column::from(next_field.db_name().to_owned()) + .set_is_enum(next_field.type_identifier().is_enum()) + .set_is_selected(true))) }), AggregationSelection::Max(fields) => fields.iter().fold(select, |select, next_field| { - select.value(max(Column::from(next_field.db_name().to_owned()))) + select.value(max(Column::from(next_field.db_name().to_owned()) + .set_is_enum(next_field.type_identifier().is_enum()) + .set_is_selected(true))) }), }, ) @@ -243,11 +249,11 @@ pub(crate) fn group_by_aggregate( }), AggregationSelection::Min(fields) => fields.iter().fold(select, |select, next_field| { - select.value(min(next_field.as_column(ctx))) + select.value(min(next_field.as_column(ctx).set_is_selected(true))) }), AggregationSelection::Max(fields) => fields.iter().fold(select, |select, next_field| { - select.value(max(next_field.as_column(ctx))) + select.value(max(next_field.as_column(ctx).set_is_selected(true))) }), }); diff --git a/query-engine/connectors/sql-query-connector/src/query_builder/write.rs b/query-engine/connectors/sql-query-connector/src/query_builder/write.rs index b9356842b28..c5bb3e24ddb 100644 --- a/query-engine/connectors/sql-query-connector/src/query_builder/write.rs +++ b/query-engine/connectors/sql-query-connector/src/query_builder/write.rs @@ -1,7 +1,7 @@ use crate::{model_extensions::*, sql_trace::SqlTraceComment, Context}; use connector_interface::{DatasourceFieldName, ScalarWriteOperation, WriteArgs}; -use prisma_models::*; use quaint::ast::*; +use query_structure::*; use std::{collections::HashSet, convert::TryInto}; use tracing::Span; diff --git a/query-engine/connectors/sql-query-connector/src/query_ext.rs b/query-engine/connectors/sql-query-connector/src/query_ext.rs index 2dba40dcb7f..a7814577347 100644 --- a/query-engine/connectors/sql-query-connector/src/query_ext.rs +++ b/query-engine/connectors/sql-query-connector/src/query_ext.rs @@ -4,13 +4,13 @@ use crate::{ value_ext::IntoTypedJsonExtension, ColumnMetadata, Context, SqlRow, ToSqlRow, }; use async_trait::async_trait; -use connector_interface::{filter::Filter, RecordFilter}; +use connector_interface::RecordFilter; use futures::future::FutureExt; use itertools::Itertools; use opentelemetry::trace::TraceContextExt; use opentelemetry::trace::TraceFlags; -use prisma_models::*; use quaint::{ast::*, connector::Queryable}; +use query_structure::*; use serde_json::{Map, Value}; use std::{collections::HashMap, panic::AssertUnwindSafe}; use tracing::{info_span, Span}; diff --git a/query-engine/connectors/sql-query-connector/src/row.rs b/query-engine/connectors/sql-query-connector/src/row.rs index 250ee7d9420..6f154b1f77d 100644 --- a/query-engine/connectors/sql-query-connector/src/row.rs +++ b/query-engine/connectors/sql-query-connector/src/row.rs @@ -2,8 +2,8 @@ use crate::{column_metadata::ColumnMetadata, error::SqlError, value::to_prisma_v use bigdecimal::{BigDecimal, FromPrimitive, ToPrimitive}; use chrono::{DateTime, NaiveDate, Utc}; use connector_interface::{coerce_null_to_zero_value, AggregationResult, AggregationSelection}; -use prisma_models::{ConversionFailure, FieldArity, PrismaValue, Record, TypeIdentifier}; use quaint::{connector::ResultRow, Value, ValueType}; +use query_structure::{ConversionFailure, FieldArity, PrismaValue, Record, TypeIdentifier}; use std::{io, str::FromStr}; use uuid::Uuid; diff --git a/query-engine/connectors/sql-query-connector/src/value.rs b/query-engine/connectors/sql-query-connector/src/value.rs index 4c31fc9eedb..0929003955f 100644 --- a/query-engine/connectors/sql-query-connector/src/value.rs +++ b/query-engine/connectors/sql-query-connector/src/value.rs @@ -1,8 +1,8 @@ use crate::row::{sanitize_f32, sanitize_f64}; use bigdecimal::{BigDecimal, FromPrimitive}; use chrono::{DateTime, NaiveDate, Utc}; -use prisma_models::PrismaValue; use quaint::ValueType; +use query_structure::PrismaValue; pub fn to_prisma_value<'a, T: Into>>(qv: T) -> crate::Result { let val = match qv.into() { diff --git a/query-engine/core/Cargo.toml b/query-engine/core/Cargo.toml index 9e0f03517cb..b23050ab7ee 100644 --- a/query-engine/core/Cargo.toml +++ b/query-engine/core/Cargo.toml @@ -19,7 +19,7 @@ indexmap = { version = "1.7", features = ["serde-1"] } itertools = "0.10" once_cell = "1" petgraph = "0.4" -prisma-models = { path = "../prisma-models", features = ["default_generators"] } +query-structure = { path = "../query-structure", features = ["default_generators"] } opentelemetry = { version = "0.17.0", features = ["rt-tokio", "serialize"] } query-engine-metrics = { path = "../metrics", optional = true } serde.workspace = true diff --git a/query-engine/core/src/constants.rs b/query-engine/core/src/constants.rs index 6d185a1c686..abf320a2969 100644 --- a/query-engine/core/src/constants.rs +++ b/query-engine/core/src/constants.rs @@ -1,5 +1,5 @@ pub mod custom_types { - use prisma_models::PrismaValue; + use query_structure::PrismaValue; pub const TYPE: &str = "$type"; pub const VALUE: &str = "value"; diff --git a/query-engine/core/src/error.rs b/query-engine/core/src/error.rs index 6ca41f1a9d7..3a3803bf0d6 100644 --- a/query-engine/core/src/error.rs +++ b/query-engine/core/src/error.rs @@ -1,6 +1,6 @@ use crate::{InterpreterError, QueryGraphBuilderError, RelationViolation, TransactionError}; use connector::error::ConnectorError; -use prisma_models::DomainError; +use query_structure::DomainError; use thiserror::Error; use user_facing_errors::UnknownError; diff --git a/query-engine/core/src/executor/request_context.rs b/query-engine/core/src/executor/request_context.rs index 13d2e724517..e4f0c7122ee 100644 --- a/query-engine/core/src/executor/request_context.rs +++ b/query-engine/core/src/executor/request_context.rs @@ -1,5 +1,5 @@ use crate::protocol::EngineProtocol; -use prisma_models::PrismaValue; +use query_structure::PrismaValue; #[derive(Debug)] struct RequestContext { diff --git a/query-engine/core/src/interpreter/error.rs b/query-engine/core/src/interpreter/error.rs index 0660c65adb7..0a60c5d7848 100644 --- a/query-engine/core/src/interpreter/error.rs +++ b/query-engine/core/src/interpreter/error.rs @@ -1,6 +1,6 @@ use crate::{QueryGraphBuilderError, QueryGraphError}; use connector::error::ConnectorError; -use prisma_models::DomainError; +use query_structure::DomainError; use std::fmt; #[derive(Debug)] diff --git a/query-engine/core/src/interpreter/interpreter_impl.rs b/query-engine/core/src/interpreter/interpreter_impl.rs index 1f4de95224c..8aa3d77ae76 100644 --- a/query-engine/core/src/interpreter/interpreter_impl.rs +++ b/query-engine/core/src/interpreter/interpreter_impl.rs @@ -6,7 +6,7 @@ use super::{ use crate::{Query, QueryResult}; use connector::ConnectionLike; use futures::future::BoxFuture; -use prisma_models::prelude::*; +use query_structure::prelude::*; use std::{collections::HashMap, fmt}; use tracing::Instrument; diff --git a/query-engine/core/src/interpreter/query_interpreters/inmemory_record_processor.rs b/query-engine/core/src/interpreter/query_interpreters/inmemory_record_processor.rs index a324b499d75..f4c0465412e 100644 --- a/query-engine/core/src/interpreter/query_interpreters/inmemory_record_processor.rs +++ b/query-engine/core/src/interpreter/query_interpreters/inmemory_record_processor.rs @@ -1,6 +1,5 @@ -use connector::QueryArguments; use itertools::Itertools; -use prisma_models::{FieldSelection, ManyRecords, Record, SelectionResult}; +use query_structure::*; use std::ops::Deref; #[derive(Debug)] diff --git a/query-engine/core/src/interpreter/query_interpreters/nested_read.rs b/query-engine/core/src/interpreter/query_interpreters/nested_read.rs index 238dd814f81..fa4dc7c6e52 100644 --- a/query-engine/core/src/interpreter/query_interpreters/nested_read.rs +++ b/query-engine/core/src/interpreter/query_interpreters/nested_read.rs @@ -1,10 +1,7 @@ use super::{inmemory_record_processor::InMemoryRecordProcessor, read}; use crate::{interpreter::InterpretationResult, query_ast::*}; -use connector::{ - self, filter::Filter, ConditionListValue, ConnectionLike, QueryArguments, RelAggregationRow, - RelAggregationSelection, ScalarCompare, -}; -use prisma_models::{FieldSelection, ManyRecords, PrismaValue, Record, RelationFieldRef, SelectionResult}; +use connector::{self, ConnectionLike, RelAggregationRow, RelAggregationSelection}; +use query_structure::*; use std::collections::HashMap; pub(crate) async fn m2m( diff --git a/query-engine/core/src/interpreter/query_interpreters/read.rs b/query-engine/core/src/interpreter/query_interpreters/read.rs index 7653c675938..464ac665167 100644 --- a/query-engine/core/src/interpreter/query_interpreters/read.rs +++ b/query-engine/core/src/interpreter/query_interpreters/read.rs @@ -3,7 +3,7 @@ use crate::{interpreter::InterpretationResult, query_ast::*, result_ast::*}; use connector::{self, error::ConnectorError, ConnectionLike, RelAggregationRow, RelAggregationSelection}; use futures::future::{BoxFuture, FutureExt}; use inmemory_record_processor::InMemoryRecordProcessor; -use prisma_models::ManyRecords; +use query_structure::ManyRecords; use std::collections::HashMap; use user_facing_errors::KnownError; diff --git a/query-engine/core/src/query_ast/mod.rs b/query-engine/core/src/query_ast/mod.rs index 43c73a65723..4b67b0ba454 100644 --- a/query-engine/core/src/query_ast/mod.rs +++ b/query-engine/core/src/query_ast/mod.rs @@ -5,8 +5,7 @@ pub use read::*; pub use write::*; use crate::ToGraphviz; -use connector::filter::Filter; -use prisma_models::{FieldSelection, Model, SelectionResult}; +use query_structure::{FieldSelection, Filter, Model, SelectionResult}; #[derive(Debug, Clone)] #[allow(clippy::large_enum_variant)] diff --git a/query-engine/core/src/query_ast/read.rs b/query-engine/core/src/query_ast/read.rs index 9b68f533300..271ff44e388 100644 --- a/query-engine/core/src/query_ast/read.rs +++ b/query-engine/core/src/query_ast/read.rs @@ -1,9 +1,9 @@ //! Prisma read query AST use super::FilteredQuery; use crate::ToGraphviz; -use connector::{filter::Filter, AggregationSelection, QueryArguments, RelAggregationSelection}; +use connector::{AggregationSelection, RelAggregationSelection}; use enumflags2::BitFlags; -use prisma_models::prelude::*; +use query_structure::{prelude::*, Filter, QueryArguments}; use std::fmt::Display; #[allow(clippy::enum_variant_names)] diff --git a/query-engine/core/src/query_ast/write.rs b/query-engine/core/src/query_ast/write.rs index 9d02e0d49d1..ee51830e796 100644 --- a/query-engine/core/src/query_ast/write.rs +++ b/query-engine/core/src/query_ast/write.rs @@ -1,8 +1,8 @@ //! Write query AST use super::{FilteredNestedMutation, FilteredQuery}; use crate::{RecordQuery, ToGraphviz}; -use connector::{filter::Filter, DatasourceFieldName, NativeUpsert, RecordFilter, WriteArgs}; -use prisma_models::prelude::*; +use connector::{DatasourceFieldName, NativeUpsert, RecordFilter, WriteArgs}; +use query_structure::{prelude::*, Filter}; use std::collections::HashMap; #[derive(Debug, Clone)] diff --git a/query-engine/core/src/query_document/argument_value.rs b/query-engine/core/src/query_document/argument_value.rs index 3d085ee57e7..7629ea73c9f 100644 --- a/query-engine/core/src/query_document/argument_value.rs +++ b/query-engine/core/src/query_document/argument_value.rs @@ -1,7 +1,7 @@ use bigdecimal::BigDecimal; use chrono::{DateTime, FixedOffset}; use indexmap::IndexMap; -use prisma_models::PrismaValue; +use query_structure::PrismaValue; use serde::Serialize; pub type ArgumentValueObject = IndexMap; diff --git a/query-engine/core/src/query_document/mod.rs b/query-engine/core/src/query_document/mod.rs index 7b86d5e87be..fa424bc44d6 100644 --- a/query-engine/core/src/query_document/mod.rs +++ b/query-engine/core/src/query_document/mod.rs @@ -32,7 +32,7 @@ use crate::{ query_ast::{QueryOption, QueryOptions}, query_graph_builder::resolve_compound_field, }; -use prisma_models::Model; +use query_structure::Model; use schema::{constants::*, QuerySchema}; use std::collections::HashMap; use user_facing_errors::query_engine::validation::ValidationError; diff --git a/query-engine/core/src/query_document/parse_ast.rs b/query-engine/core/src/query_document/parse_ast.rs index b9d1e8f6816..256763f59e6 100644 --- a/query-engine/core/src/query_document/parse_ast.rs +++ b/query-engine/core/src/query_document/parse_ast.rs @@ -2,7 +2,7 @@ //! Structures represent parsed and validated parts of the query document, used by the query builders. use crate::QueryParserResult; use indexmap::IndexMap; -use prisma_models::{OrderBy, PrismaValue, ScalarFieldRef}; +use query_structure::{OrderBy, PrismaValue, ScalarFieldRef}; use schema::ObjectTag; use std::{ borrow::Cow, diff --git a/query-engine/core/src/query_document/parser.rs b/query-engine/core/src/query_document/parser.rs index 58a81469227..79f30e1bd8b 100644 --- a/query-engine/core/src/query_document/parser.rs +++ b/query-engine/core/src/query_document/parser.rs @@ -4,7 +4,7 @@ use bigdecimal::{BigDecimal, ToPrimitive}; use chrono::prelude::*; use core::fmt; use indexmap::{IndexMap, IndexSet}; -use prisma_models::{DefaultKind, PrismaValue, ValueGeneratorFn}; +use query_structure::{DefaultKind, PrismaValue, ValueGeneratorFn}; use std::{borrow::Cow, convert::TryFrom, rc::Rc, str::FromStr}; use user_facing_errors::query_engine::validation::ValidationError; use uuid::Uuid; @@ -414,7 +414,7 @@ impl QueryDocumentParser { argument_path: &Path, s: &str, ) -> QueryParserResult> { - prisma_models::parse_datetime(s).map_err(|err| { + query_structure::parse_datetime(s).map_err(|err| { ValidationError::invalid_argument_value( selection_path.segments(), argument_path.segments(), @@ -426,15 +426,17 @@ impl QueryDocumentParser { } fn parse_bytes(&self, selection_path: &Path, argument_path: &Path, s: String) -> QueryParserResult { - prisma_models::decode_bytes(&s).map(PrismaValue::Bytes).map_err(|err| { - ValidationError::invalid_argument_value( - selection_path.segments(), - argument_path.segments(), - s.to_string(), - "base64 String", - Some(Box::new(err)), - ) - }) + query_structure::decode_bytes(&s) + .map(PrismaValue::Bytes) + .map_err(|err| { + ValidationError::invalid_argument_value( + selection_path.segments(), + argument_path.segments(), + s.to_string(), + "base64 String", + Some(Box::new(err)), + ) + }) } fn parse_decimal( @@ -782,7 +784,7 @@ pub(crate) mod conversions { schema::{InputType, OutputType}, ArgumentValue, }; - use prisma_models::PrismaValue; + use query_structure::PrismaValue; use schema::InnerOutputType; use user_facing_errors::query_engine::validation::{self, InputTypeDescription}; diff --git a/query-engine/core/src/query_document/transformers.rs b/query-engine/core/src/query_document/transformers.rs index 8d5894e9bbc..20296b7ff04 100644 --- a/query-engine/core/src/query_document/transformers.rs +++ b/query-engine/core/src/query_document/transformers.rs @@ -7,7 +7,7 @@ use super::*; use bigdecimal::ToPrimitive; use chrono::prelude::*; -use prisma_models::{OrderBy, PrismaValue, ScalarFieldRef}; +use query_structure::{OrderBy, PrismaValue, ScalarFieldRef}; use std::convert::TryInto; use user_facing_errors::query_engine::validation::ValidationError; diff --git a/query-engine/core/src/query_graph/mod.rs b/query-engine/core/src/query_graph/mod.rs index e51dcea9711..6086fa24333 100644 --- a/query-engine/core/src/query_graph/mod.rs +++ b/query-engine/core/src/query_graph/mod.rs @@ -10,7 +10,6 @@ use crate::{ interpreter::ExpressionResult, FilteredQuery, ManyRecordsQuery, Query, QueryGraphBuilderResult, QueryOptions, ReadQuery, }; -use connector::{IntoFilter, QueryArguments}; use guard::*; use itertools::Itertools; use petgraph::{ @@ -18,7 +17,7 @@ use petgraph::{ visit::{EdgeRef as PEdgeRef, NodeIndexable}, *, }; -use prisma_models::{FieldSelection, SelectionResult}; +use query_structure::{FieldSelection, IntoFilter, QueryArguments, SelectionResult}; use std::{collections::HashSet, fmt}; pub type QueryGraphResult = std::result::Result; diff --git a/query-engine/core/src/query_graph_builder/error.rs b/query-engine/core/src/query_graph_builder/error.rs index 6fa1b82001a..825b312bbbf 100644 --- a/query-engine/core/src/query_graph_builder/error.rs +++ b/query-engine/core/src/query_graph_builder/error.rs @@ -1,5 +1,5 @@ use crate::QueryGraphError; -use prisma_models::{DomainError, RelationFieldRef}; +use query_structure::{DomainError, RelationFieldRef}; use user_facing_errors::query_engine::validation::ValidationError; #[derive(Debug)] diff --git a/query-engine/core/src/query_graph_builder/extractors/filters/composite.rs b/query-engine/core/src/query_graph_builder/extractors/filters/composite.rs index 9bb26c38889..66bd7c44ebb 100644 --- a/query-engine/core/src/query_graph_builder/extractors/filters/composite.rs +++ b/query-engine/core/src/query_graph_builder/extractors/filters/composite.rs @@ -1,7 +1,6 @@ use super::extract_filter; use crate::{ParsedInputMap, ParsedInputValue, QueryGraphBuilderError, QueryGraphBuilderResult}; -use connector::{CompositeCompare, Filter}; -use prisma_models::{CompositeFieldRef, PrismaValue}; +use query_structure::{CompositeCompare, CompositeFieldRef, Filter, PrismaValue}; use schema::{constants::filters, ObjectTag}; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/extractors/filters/filter_fold.rs b/query-engine/core/src/query_graph_builder/extractors/filters/filter_fold.rs index 46ef17314c3..3438ecec847 100644 --- a/query-engine/core/src/query_graph_builder/extractors/filters/filter_fold.rs +++ b/query-engine/core/src/query_graph_builder/extractors/filters/filter_fold.rs @@ -1,4 +1,4 @@ -use connector::Filter; +use query_structure::Filter; pub fn fold_filter(filter: Filter) -> Filter { match filter { diff --git a/query-engine/core/src/query_graph_builder/extractors/filters/mod.rs b/query-engine/core/src/query_graph_builder/extractors/filters/mod.rs index e15aca25066..cb9e4e7f802 100644 --- a/query-engine/core/src/query_graph_builder/extractors/filters/mod.rs +++ b/query-engine/core/src/query_graph_builder/extractors/filters/mod.rs @@ -9,15 +9,10 @@ use crate::{ query_document::{ParsedInputMap, ParsedInputValue}, QueryGraphBuilderError, QueryGraphBuilderResult, }; -use connector::{ - filter::Filter, CompositeCompare, QueryMode, RelationCompare, ScalarCompare, ScalarCondition, ScalarProjection, -}; use filter_fold::*; use filter_grouping::*; use indexmap::IndexMap; -use prisma_models::{ - prelude::ParentContainer, CompositeFieldRef, Field, Model, PrismaValue, RelationFieldRef, ScalarFieldRef, -}; +use query_structure::{prelude::ParentContainer, *}; use schema::constants::filters; use std::{borrow::Cow, collections::HashMap, convert::TryInto, str::FromStr}; diff --git a/query-engine/core/src/query_graph_builder/extractors/filters/relation.rs b/query-engine/core/src/query_graph_builder/extractors/filters/relation.rs index e3df0144f67..47ec7ab9d19 100644 --- a/query-engine/core/src/query_graph_builder/extractors/filters/relation.rs +++ b/query-engine/core/src/query_graph_builder/extractors/filters/relation.rs @@ -1,7 +1,6 @@ use super::extract_filter; use crate::{ParsedInputMap, ParsedInputValue, QueryGraphBuilderError, QueryGraphBuilderResult}; -use connector::{Filter, RelationCompare}; -use prisma_models::RelationFieldRef; +use query_structure::*; use schema::constants::filters; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/extractors/filters/scalar.rs b/query-engine/core/src/query_graph_builder/extractors/filters/scalar.rs index 0c3a100b7af..ac84ce06aa2 100644 --- a/query-engine/core/src/query_graph_builder/extractors/filters/scalar.rs +++ b/query-engine/core/src/query_graph_builder/extractors/filters/scalar.rs @@ -1,9 +1,5 @@ use crate::{ParsedInputMap, ParsedInputValue, QueryGraphBuilderError, QueryGraphBuilderResult}; -use connector::{ - ConditionListValue, ConditionValue, Filter, JsonCompare, JsonFilterPath, JsonTargetType, ScalarCompare, - ScalarListCompare, -}; -use prisma_models::{prelude::ParentContainer, Field, PrismaValue, ScalarFieldRef, TypeIdentifier}; +use query_structure::{prelude::ParentContainer, *}; use schema::constants::{aggregations, filters, json_null}; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/extractors/query_arguments.rs b/query-engine/core/src/query_graph_builder/extractors/query_arguments.rs index f4c890aa7d0..e42cdaca63f 100644 --- a/query-engine/core/src/query_graph_builder/extractors/query_arguments.rs +++ b/query-engine/core/src/query_graph_builder/extractors/query_arguments.rs @@ -3,8 +3,7 @@ use crate::{ query_document::{ParsedArgument, ParsedInputMap}, QueryGraphBuilderError, QueryGraphBuilderResult, }; -use connector::QueryArguments; -use prisma_models::prelude::*; +use query_structure::{prelude::*, QueryArguments}; use schema::constants::{aggregations, args, ordering}; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/extractors/utils.rs b/query-engine/core/src/query_graph_builder/extractors/utils.rs index d216db2706f..b05720d4f72 100644 --- a/query-engine/core/src/query_graph_builder/extractors/utils.rs +++ b/query-engine/core/src/query_graph_builder/extractors/utils.rs @@ -1,4 +1,4 @@ -use prisma_models::{Model, ScalarFieldRef}; +use query_structure::{Model, ScalarFieldRef}; /// Attempts to resolve a field name to a compound field. pub fn resolve_compound_field(name: &str, model: &Model) -> Option> { diff --git a/query-engine/core/src/query_graph_builder/read/aggregations/aggregate.rs b/query-engine/core/src/query_graph_builder/read/aggregations/aggregate.rs index 91e5d1169aa..6a6332dbd86 100644 --- a/query-engine/core/src/query_graph_builder/read/aggregations/aggregate.rs +++ b/query-engine/core/src/query_graph_builder/read/aggregations/aggregate.rs @@ -1,6 +1,6 @@ use super::*; use crate::{query_document::ParsedField, AggregateRecordsQuery}; -use prisma_models::Model; +use query_structure::Model; pub(crate) fn aggregate(field: ParsedField<'_>, model: Model) -> QueryGraphBuilderResult { let name = field.name; diff --git a/query-engine/core/src/query_graph_builder/read/aggregations/group_by.rs b/query-engine/core/src/query_graph_builder/read/aggregations/group_by.rs index 167c35f78bf..5b821b46000 100644 --- a/query-engine/core/src/query_graph_builder/read/aggregations/group_by.rs +++ b/query-engine/core/src/query_graph_builder/read/aggregations/group_by.rs @@ -1,7 +1,6 @@ use super::*; use crate::{query_document::ParsedField, AggregateRecordsQuery, ArgumentListLookup, ParsedInputValue, ReadQuery}; -use connector::Filter; -use prisma_models::{Model, OrderBy, ScalarFieldRef}; +use query_structure::{Filter, Model, OrderBy, ScalarFieldRef}; use schema::constants::args; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/read/aggregations/mod.rs b/query-engine/core/src/query_graph_builder/read/aggregations/mod.rs index 43354d70807..94e8b1bcbdc 100644 --- a/query-engine/core/src/query_graph_builder/read/aggregations/mod.rs +++ b/query-engine/core/src/query_graph_builder/read/aggregations/mod.rs @@ -8,7 +8,7 @@ use super::*; use crate::FieldPair; use connector::AggregationSelection; use itertools::Itertools; -use prisma_models::{Model, ScalarFieldRef}; +use query_structure::{Model, ScalarFieldRef}; use schema::constants::aggregations::*; /// Resolves the given field as a aggregation query. diff --git a/query-engine/core/src/query_graph_builder/read/first.rs b/query-engine/core/src/query_graph_builder/read/first.rs index c68969b07b1..84c90016858 100644 --- a/query-engine/core/src/query_graph_builder/read/first.rs +++ b/query-engine/core/src/query_graph_builder/read/first.rs @@ -1,4 +1,4 @@ -use prisma_models::Model; +use query_structure::Model; use super::*; use crate::ParsedField; diff --git a/query-engine/core/src/query_graph_builder/read/many.rs b/query-engine/core/src/query_graph_builder/read/many.rs index b84b546dcfd..6c9242330a8 100644 --- a/query-engine/core/src/query_graph_builder/read/many.rs +++ b/query-engine/core/src/query_graph_builder/read/many.rs @@ -1,6 +1,6 @@ use super::*; use crate::{query_document::ParsedField, ManyRecordsQuery, QueryOption, QueryOptions, ReadQuery}; -use prisma_models::Model; +use query_structure::Model; pub(crate) fn find_many(field: ParsedField<'_>, model: Model) -> QueryGraphBuilderResult { find_many_with_options(field, model, QueryOptions::none()) diff --git a/query-engine/core/src/query_graph_builder/read/one.rs b/query-engine/core/src/query_graph_builder/read/one.rs index edb7425bc20..d71c2535bb2 100644 --- a/query-engine/core/src/query_graph_builder/read/one.rs +++ b/query-engine/core/src/query_graph_builder/read/one.rs @@ -1,6 +1,6 @@ use super::*; use crate::{query_document::*, QueryOption, QueryOptions, ReadQuery, RecordQuery}; -use prisma_models::Model; +use query_structure::Model; use schema::constants::args; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/read/related.rs b/query-engine/core/src/query_graph_builder/read/related.rs index c8beb952e02..9c73699b047 100644 --- a/query-engine/core/src/query_graph_builder/read/related.rs +++ b/query-engine/core/src/query_graph_builder/read/related.rs @@ -1,6 +1,6 @@ use super::*; use crate::{query_document::ParsedField, ReadQuery, RelatedRecordsQuery}; -use prisma_models::{Model, RelationFieldRef}; +use query_structure::{Model, RelationFieldRef}; pub(crate) fn find_related( field: ParsedField<'_>, diff --git a/query-engine/core/src/query_graph_builder/read/utils.rs b/query-engine/core/src/query_graph_builder/read/utils.rs index 234a50d6f09..545393ba3d1 100644 --- a/query-engine/core/src/query_graph_builder/read/utils.rs +++ b/query-engine/core/src/query_graph_builder/read/utils.rs @@ -1,7 +1,7 @@ use super::*; use crate::{ArgumentListLookup, FieldPair, ParsedField, ReadQuery}; use connector::RelAggregationSelection; -use prisma_models::prelude::*; +use query_structure::prelude::*; use schema::constants::{aggregations::*, args}; pub fn collect_selection_order(from: &[FieldPair<'_>]) -> Vec { diff --git a/query-engine/core/src/query_graph_builder/write/connect.rs b/query-engine/core/src/query_graph_builder/write/connect.rs index 7df971de5e6..03e681477ca 100644 --- a/query-engine/core/src/query_graph_builder/write/connect.rs +++ b/query-engine/core/src/query_graph_builder/write/connect.rs @@ -3,7 +3,7 @@ use crate::{ query_graph::{Node, NodeRef, QueryGraph, QueryGraphDependency}, QueryGraphBuilderError, QueryGraphBuilderResult, }; -use prisma_models::RelationFieldRef; +use query_structure::RelationFieldRef; /// Only for many to many relations. /// diff --git a/query-engine/core/src/query_graph_builder/write/create.rs b/query-engine/core/src/query_graph_builder/write/create.rs index 7707f481851..59661c6c16b 100644 --- a/query-engine/core/src/query_graph_builder/write/create.rs +++ b/query-engine/core/src/query_graph_builder/write/create.rs @@ -4,9 +4,8 @@ use crate::{ query_graph::{Node, NodeRef, QueryGraph, QueryGraphDependency}, ArgumentListLookup, ParsedField, ParsedInputList, ParsedInputMap, }; -use connector::IntoFilter; -use prisma_models::Model; use psl::datamodel_connector::ConnectorCapability; +use query_structure::{IntoFilter, Model}; use schema::{constants::args, QuerySchema}; use std::convert::TryInto; use write_args_parser::*; diff --git a/query-engine/core/src/query_graph_builder/write/delete.rs b/query-engine/core/src/query_graph_builder/write/delete.rs index a5bca5af775..df6a6643602 100644 --- a/query-engine/core/src/query_graph_builder/write/delete.rs +++ b/query-engine/core/src/query_graph_builder/write/delete.rs @@ -4,8 +4,7 @@ use crate::{ query_graph::{Node, QueryGraph, QueryGraphDependency}, ArgumentListLookup, FilteredQuery, ParsedField, }; -use connector::filter::Filter; -use prisma_models::Model; +use query_structure::{Filter, Model}; use schema::{constants::args, QuerySchema}; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/write/disconnect.rs b/query-engine/core/src/query_graph_builder/write/disconnect.rs index fea9d6f4f14..e354e9dc540 100644 --- a/query-engine/core/src/query_graph_builder/write/disconnect.rs +++ b/query-engine/core/src/query_graph_builder/write/disconnect.rs @@ -3,7 +3,7 @@ use crate::{ query_graph::{Node, NodeRef, QueryGraph, QueryGraphDependency}, QueryGraphBuilderError, QueryGraphBuilderResult, }; -use prisma_models::RelationFieldRef; +use query_structure::RelationFieldRef; /// Only for many to many relations. /// diff --git a/query-engine/core/src/query_graph_builder/write/nested/connect_nested.rs b/query-engine/core/src/query_graph_builder/write/nested/connect_nested.rs index 6052778037d..81038c18a57 100644 --- a/query-engine/core/src/query_graph_builder/write/nested/connect_nested.rs +++ b/query-engine/core/src/query_graph_builder/write/nested/connect_nested.rs @@ -4,9 +4,8 @@ use crate::{ query_graph::{Node, NodeRef, QueryGraph, QueryGraphDependency}, ParsedInputMap, ParsedInputValue, QueryResult, }; -use connector::{Filter, IntoFilter}; use itertools::Itertools; -use prisma_models::{Model, RelationFieldRef}; +use query_structure::{Filter, IntoFilter, Model, RelationFieldRef}; use std::convert::TryInto; /// Handles nested connect cases. diff --git a/query-engine/core/src/query_graph_builder/write/nested/connect_or_create_nested.rs b/query-engine/core/src/query_graph_builder/write/nested/connect_or_create_nested.rs index bbe63701cbd..bcaacc1f581 100644 --- a/query-engine/core/src/query_graph_builder/write/nested/connect_or_create_nested.rs +++ b/query-engine/core/src/query_graph_builder/write/nested/connect_or_create_nested.rs @@ -4,8 +4,7 @@ use crate::{ query_graph::{Flow, Node, NodeRef, QueryGraph, QueryGraphDependency}, Computation, ParsedInputMap, ParsedInputValue, }; -use connector::{Filter, IntoFilter}; -use prisma_models::{Model, RelationFieldRef, SelectionResult}; +use query_structure::{Filter, IntoFilter, Model, RelationFieldRef, SelectionResult}; use schema::constants::args; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/write/nested/create_nested.rs b/query-engine/core/src/query_graph_builder/write/nested/create_nested.rs index 80229d01851..d0f649c3ecf 100644 --- a/query-engine/core/src/query_graph_builder/write/nested/create_nested.rs +++ b/query-engine/core/src/query_graph_builder/write/nested/create_nested.rs @@ -5,8 +5,7 @@ use crate::{ write::write_args_parser::WriteArgsParser, ParsedInputList, ParsedInputValue, }; -use connector::{Filter, IntoFilter}; -use prisma_models::{Model, RelationFieldRef}; +use query_structure::{Filter, IntoFilter, Model, RelationFieldRef}; use schema::constants::args; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/write/nested/delete_nested.rs b/query-engine/core/src/query_graph_builder/write/nested/delete_nested.rs index 875902a7eca..ceed2b578b0 100644 --- a/query-engine/core/src/query_graph_builder/write/nested/delete_nested.rs +++ b/query-engine/core/src/query_graph_builder/write/nested/delete_nested.rs @@ -4,8 +4,8 @@ use crate::{ query_graph::{Node, NodeRef, QueryGraph, QueryGraphDependency}, ParsedInputMap, ParsedInputValue, }; -use connector::{Filter, RecordFilter}; -use prisma_models::{Model, PrismaValue, RelationFieldRef}; +use connector::RecordFilter; +use query_structure::{Filter, Model, PrismaValue, RelationFieldRef}; use std::convert::TryInto; /// Adds a delete (single) record node to the graph and connects it to the parent. diff --git a/query-engine/core/src/query_graph_builder/write/nested/disconnect_nested.rs b/query-engine/core/src/query_graph_builder/write/nested/disconnect_nested.rs index 1b4c208a785..841b7722eb2 100644 --- a/query-engine/core/src/query_graph_builder/write/nested/disconnect_nested.rs +++ b/query-engine/core/src/query_graph_builder/write/nested/disconnect_nested.rs @@ -3,9 +3,8 @@ use crate::{ query_graph::{Node, NodeRef, QueryGraph, QueryGraphDependency}, ParsedInputMap, ParsedInputValue, Query, WriteQuery, }; -use connector::{Filter, RelationCompare}; use itertools::Itertools; -use prisma_models::{Model, PrismaValue, RelationFieldRef, SelectionResult}; +use query_structure::{Filter, Model, PrismaValue, RelationCompare, RelationFieldRef, SelectionResult}; use std::convert::TryInto; /// Handles nested disconnect cases. diff --git a/query-engine/core/src/query_graph_builder/write/nested/mod.rs b/query-engine/core/src/query_graph_builder/write/nested/mod.rs index 7f8049c7643..5d0ad21a4c7 100644 --- a/query-engine/core/src/query_graph_builder/write/nested/mod.rs +++ b/query-engine/core/src/query_graph_builder/write/nested/mod.rs @@ -17,7 +17,7 @@ use connect_or_create_nested::*; use create_nested::*; use delete_nested::*; use disconnect_nested::*; -use prisma_models::RelationFieldRef; +use query_structure::RelationFieldRef; use schema::{constants::operations, QuerySchema}; use set_nested::*; use update_nested::*; diff --git a/query-engine/core/src/query_graph_builder/write/nested/set_nested.rs b/query-engine/core/src/query_graph_builder/write/nested/set_nested.rs index 0f71bc2816a..67fa227aa2c 100644 --- a/query-engine/core/src/query_graph_builder/write/nested/set_nested.rs +++ b/query-engine/core/src/query_graph_builder/write/nested/set_nested.rs @@ -1,8 +1,7 @@ use super::*; use crate::{query_ast::*, query_graph::*, ParsedInputValue}; -use connector::Filter; use itertools::Itertools; -use prisma_models::{Model, RelationFieldRef, SelectionResult}; +use query_structure::{Filter, Model, RelationFieldRef, SelectionResult}; use std::convert::TryInto; /// Only for x-to-many relations. diff --git a/query-engine/core/src/query_graph_builder/write/nested/update_nested.rs b/query-engine/core/src/query_graph_builder/write/nested/update_nested.rs index bca227dd3a0..78bf69af2f7 100644 --- a/query-engine/core/src/query_graph_builder/write/nested/update_nested.rs +++ b/query-engine/core/src/query_graph_builder/write/nested/update_nested.rs @@ -4,8 +4,7 @@ use crate::{ query_graph::{Node, NodeRef, QueryGraph, QueryGraphDependency}, ParsedInputValue, }; -use connector::Filter; -use prisma_models::{Model, RelationFieldRef}; +use query_structure::{Filter, Model, RelationFieldRef}; use schema::constants::args; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/write/nested/upsert_nested.rs b/query-engine/core/src/query_graph_builder/write/nested/upsert_nested.rs index 006c0b51609..0e72e1fa141 100644 --- a/query-engine/core/src/query_graph_builder/write/nested/upsert_nested.rs +++ b/query-engine/core/src/query_graph_builder/write/nested/upsert_nested.rs @@ -5,8 +5,7 @@ use crate::{ query_graph::{Flow, Node, NodeRef, QueryGraph, QueryGraphDependency}, ParsedInputMap, ParsedInputValue, }; -use connector::Filter; -use prisma_models::RelationFieldRef; +use query_structure::{Filter, RelationFieldRef}; use schema::constants::args; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/write/raw.rs b/query-engine/core/src/query_graph_builder/write/raw.rs index 80835b9691c..af44770aa3f 100644 --- a/query-engine/core/src/query_graph_builder/write/raw.rs +++ b/query-engine/core/src/query_graph_builder/write/raw.rs @@ -1,6 +1,6 @@ use super::*; use crate::{query_ast::*, query_graph::QueryGraph, ParsedField}; -use prisma_models::{Model, PrismaValue}; +use query_structure::{Model, PrismaValue}; use std::{collections::HashMap, convert::TryInto}; pub(crate) fn execute_raw(graph: &mut QueryGraph, field: ParsedField<'_>) -> QueryGraphBuilderResult<()> { diff --git a/query-engine/core/src/query_graph_builder/write/update.rs b/query-engine/core/src/query_graph_builder/write/update.rs index 847efc38410..001e2b48a96 100644 --- a/query-engine/core/src/query_graph_builder/write/update.rs +++ b/query-engine/core/src/query_graph_builder/write/update.rs @@ -5,9 +5,8 @@ use crate::{ query_graph::{Node, NodeRef, QueryGraph, QueryGraphDependency}, ArgumentListLookup, ParsedField, ParsedInputMap, }; -use connector::{Filter, IntoFilter}; -use prisma_models::Model; use psl::datamodel_connector::ConnectorCapability; +use query_structure::{Filter, IntoFilter, Model}; use schema::{constants::args, QuerySchema}; use std::convert::TryInto; diff --git a/query-engine/core/src/query_graph_builder/write/upsert.rs b/query-engine/core/src/query_graph_builder/write/upsert.rs index 0a01e43e73c..92fcd6d12ef 100644 --- a/query-engine/core/src/query_graph_builder/write/upsert.rs +++ b/query-engine/core/src/query_graph_builder/write/upsert.rs @@ -4,8 +4,7 @@ use crate::{ query_graph::{Flow, Node, QueryGraph, QueryGraphDependency}, ParsedField, ParsedInputMap, ParsedInputValue, ParsedObject, }; -use connector::IntoFilter; -use prisma_models::Model; +use query_structure::{IntoFilter, Model}; use schema::QuerySchema; /// Handles a top-level upsert diff --git a/query-engine/core/src/query_graph_builder/write/utils.rs b/query-engine/core/src/query_graph_builder/write/utils.rs index 113e09e3923..2f2e736aeda 100644 --- a/query-engine/core/src/query_graph_builder/write/utils.rs +++ b/query-engine/core/src/query_graph_builder/write/utils.rs @@ -3,10 +3,10 @@ use crate::{ query_graph::{Flow, Node, NodeRef, QueryGraph, QueryGraphDependency}, Computation, ParsedInputValue, QueryGraphBuilderError, QueryGraphBuilderResult, }; -use connector::{DatasourceFieldName, Filter, RecordFilter, WriteArgs, WriteOperation}; +use connector::{DatasourceFieldName, RecordFilter, WriteArgs, WriteOperation}; use indexmap::IndexMap; -use prisma_models::{FieldSelection, Model, PrismaValue, RelationFieldRef, SelectionResult}; use psl::parser_database::ReferentialAction; +use query_structure::{FieldSelection, Filter, Model, PrismaValue, RelationFieldRef, SelectionResult}; use schema::QuerySchema; /// Coerces single values (`ParsedInputValue::Single` and `ParsedInputValue::Map`) into a vector. diff --git a/query-engine/core/src/query_graph_builder/write/write_args_parser.rs b/query-engine/core/src/query_graph_builder/write/write_args_parser.rs index c5473065ac6..255247e4cee 100644 --- a/query-engine/core/src/query_graph_builder/write/write_args_parser.rs +++ b/query-engine/core/src/query_graph_builder/write/write_args_parser.rs @@ -1,7 +1,7 @@ use super::*; use crate::query_document::{ParsedInputMap, ParsedInputValue}; use connector::{DatasourceFieldName, WriteArgs, WriteOperation}; -use prisma_models::{CompositeFieldRef, Field, Model, PrismaValue, RelationFieldRef, ScalarFieldRef, TypeIdentifier}; +use query_structure::{CompositeFieldRef, Field, Model, PrismaValue, RelationFieldRef, ScalarFieldRef, TypeIdentifier}; use schema::constants::{args, json_null, operations}; use std::{borrow::Cow, convert::TryInto}; diff --git a/query-engine/core/src/response_ir/internal.rs b/query-engine/core/src/response_ir/internal.rs index 2ad67707f22..7becb19e768 100644 --- a/query-engine/core/src/response_ir/internal.rs +++ b/query-engine/core/src/response_ir/internal.rs @@ -5,7 +5,7 @@ use crate::{ use connector::{AggregationResult, RelAggregationResult, RelAggregationRow}; use indexmap::IndexMap; use itertools::Itertools; -use prisma_models::{CompositeFieldRef, Field, PrismaValue, SelectionResult}; +use query_structure::{CompositeFieldRef, Field, PrismaValue, SelectionResult}; use schema::{ constants::{aggregations::*, output_fields::*}, *, diff --git a/query-engine/core/src/response_ir/ir_serializer.rs b/query-engine/core/src/response_ir/ir_serializer.rs index 4e69b5534e1..d8efa710bff 100644 --- a/query-engine/core/src/response_ir/ir_serializer.rs +++ b/query-engine/core/src/response_ir/ir_serializer.rs @@ -1,6 +1,6 @@ use super::{internal::serialize_internal, response::*, *}; use crate::{CoreError, ExpressionResult, QueryResult}; -use prisma_models::PrismaValue; +use query_structure::PrismaValue; use schema::{OutputField, QuerySchema}; #[derive(Debug)] diff --git a/query-engine/core/src/response_ir/mod.rs b/query-engine/core/src/response_ir/mod.rs index e53422ff896..e9a4eeb0c9a 100644 --- a/query-engine/core/src/response_ir/mod.rs +++ b/query-engine/core/src/response_ir/mod.rs @@ -18,7 +18,7 @@ pub(crate) use ir_serializer::*; use crate::ArgumentValue; use indexmap::IndexMap; -use prisma_models::PrismaValue; +use query_structure::PrismaValue; use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer}; use std::{collections::HashMap, fmt, sync::Arc}; diff --git a/query-engine/core/src/result_ast/mod.rs b/query-engine/core/src/result_ast/mod.rs index 636fa611607..91c58f8551a 100644 --- a/query-engine/core/src/result_ast/mod.rs +++ b/query-engine/core/src/result_ast/mod.rs @@ -1,5 +1,5 @@ use connector::{AggregationRow, RelAggregationRow}; -use prisma_models::{ManyRecords, Model, SelectionResult}; +use query_structure::{ManyRecords, Model, SelectionResult}; #[derive(Debug, Clone)] pub(crate) enum QueryResult { diff --git a/query-engine/dmmf/Cargo.toml b/query-engine/dmmf/Cargo.toml index cc92c914d4e..367c87be5a6 100644 --- a/query-engine/dmmf/Cargo.toml +++ b/query-engine/dmmf/Cargo.toml @@ -10,7 +10,7 @@ serde.workspace = true serde_json.workspace = true schema = { path = "../schema" } indexmap = { version = "1.7", features = ["serde-1"] } -prisma-models = { path = "../prisma-models", features = ["default_generators"] } +query-structure = { path = "../query-structure", features = ["default_generators"] } [dev-dependencies] expect-test = "1.2.2" diff --git a/query-engine/dmmf/src/ast_builders/datamodel_ast_builder.rs b/query-engine/dmmf/src/ast_builders/datamodel_ast_builder.rs index 8d078719d4f..c367695150f 100644 --- a/query-engine/dmmf/src/ast_builders/datamodel_ast_builder.rs +++ b/query-engine/dmmf/src/ast_builders/datamodel_ast_builder.rs @@ -2,11 +2,11 @@ use crate::serialization_ast::datamodel_ast::{ Datamodel, Enum, EnumValue, Field, Function, Model, PrimaryKey, UniqueIndex, }; use bigdecimal::ToPrimitive; -use prisma_models::{dml_default_kind, encode_bytes, DefaultKind, FieldArity, PrismaValue}; use psl::{ parser_database::{walkers, ScalarFieldType}, schema_ast::ast::WithDocumentation, }; +use query_structure::{dml_default_kind, encode_bytes, DefaultKind, FieldArity, PrismaValue}; pub(crate) fn schema_to_dmmf(schema: &psl::ValidatedSchema) -> Datamodel { let mut datamodel = Datamodel { diff --git a/query-engine/driver-adapters/src/async_js_function.rs b/query-engine/driver-adapters/src/async_js_function.rs index 5f535334ffb..4926534f58b 100644 --- a/query-engine/driver-adapters/src/async_js_function.rs +++ b/query-engine/driver-adapters/src/async_js_function.rs @@ -55,6 +55,10 @@ where .map_err(into_quaint_error)?; js_result.into() } + + pub(crate) fn as_raw(&self) -> &ThreadsafeFunction { + &self.threadsafe_fn + } } impl FromNapiValue for AsyncJsFunction diff --git a/query-engine/driver-adapters/src/proxy.rs b/query-engine/driver-adapters/src/proxy.rs index 642c2491757..19693453988 100644 --- a/query-engine/driver-adapters/src/proxy.rs +++ b/query-engine/driver-adapters/src/proxy.rs @@ -1,12 +1,12 @@ use std::borrow::Cow; use std::str::FromStr; +use std::sync::atomic::{AtomicBool, Ordering}; use crate::async_js_function::AsyncJsFunction; use crate::conversion::JSArg; use crate::transaction::JsTransaction; use metrics::increment_gauge; use napi::bindgen_prelude::{FromNapiValue, ToNapiValue}; -use napi::threadsafe_function::{ErrorStrategy, ThreadsafeFunction}; use napi::{JsObject, JsString}; use napi_derive::napi; use quaint::connector::ResultSet as QuaintResultSet; @@ -52,9 +52,8 @@ pub(crate) struct TransactionProxy { /// rollback transaction rollback: AsyncJsFunction<(), ()>, - /// dispose transaction, cleanup logic executed at the end of the transaction lifecycle - /// on drop. - dispose: ThreadsafeFunction<(), ErrorStrategy::Fatal>, + /// whether the transaction has already been committed or rolled back + closed: AtomicBool, } /// This result set is more convenient to be manipulated from both Rust and NodeJS. @@ -581,14 +580,13 @@ impl TransactionProxy { pub fn new(js_transaction: &JsObject) -> napi::Result { let commit = js_transaction.get_named_property("commit")?; let rollback = js_transaction.get_named_property("rollback")?; - let dispose = js_transaction.get_named_property("dispose")?; let options = js_transaction.get_named_property("options")?; Ok(Self { commit, rollback, - dispose, options, + closed: AtomicBool::new(false), }) } @@ -596,19 +594,56 @@ impl TransactionProxy { &self.options } + /// Commits the transaction via the driver adapter. + /// + /// ## Cancellation safety + /// + /// The future is cancellation-safe as long as the underlying Node-API call + /// is cancellation-safe and no new await points are introduced between storing true in + /// [`TransactionProxy::closed`] and calling the underlying JS function. + /// + /// - If `commit` is called but never polled or awaited, it's a no-op, the transaction won't be + /// committed and [`TransactionProxy::closed`] will not be changed. + /// + /// - If it is polled at least once, `true` will be stored in [`TransactionProxy::closed`] and + /// the underlying FFI call will be delivered to JavaScript side in lockstep, so the destructor + /// will not attempt rolling the transaction back even if the `commit` future was dropped while + /// waiting on the JavaScript call to complete and deliver response. pub async fn commit(&self) -> quaint::Result<()> { + self.closed.store(true, Ordering::Relaxed); self.commit.call(()).await } + /// Rolls back the transaction via the driver adapter. + /// + /// ## Cancellation safety + /// + /// The future is cancellation-safe as long as the underlying Node-API call + /// is cancellation-safe and no new await points are introduced between storing true in + /// [`TransactionProxy::closed`] and calling the underlying JS function. + /// + /// - If `rollback` is called but never polled or awaited, it's a no-op, the transaction won't be + /// rolled back yet and [`TransactionProxy::closed`] will not be changed. + /// + /// - If it is polled at least once, `true` will be stored in [`TransactionProxy::closed`] and + /// the underlying FFI call will be delivered to JavaScript side in lockstep, so the destructor + /// will not attempt rolling back again even if the `rollback` future was dropped while waiting + /// on the JavaScript call to complete and deliver response. pub async fn rollback(&self) -> quaint::Result<()> { + self.closed.store(true, Ordering::Relaxed); self.rollback.call(()).await } } impl Drop for TransactionProxy { fn drop(&mut self) { + if self.closed.swap(true, Ordering::Relaxed) { + return; + } + _ = self - .dispose + .rollback + .as_raw() .call((), napi::threadsafe_function::ThreadsafeFunctionCallMode::NonBlocking); } } diff --git a/query-engine/query-engine-node-api/Cargo.toml b/query-engine/query-engine-node-api/Cargo.toml index 0eaed9eff7c..ec5783466f7 100644 --- a/query-engine/query-engine-node-api/Cargo.toml +++ b/query-engine/query-engine-node-api/Cargo.toml @@ -22,7 +22,7 @@ query-connector = { path = "../connectors/query-connector" } user-facing-errors = { path = "../../libs/user-facing-errors" } psl.workspace = true sql-connector = { path = "../connectors/sql-query-connector", package = "sql-query-connector" } -prisma-models = { path = "../prisma-models" } +query-structure = { path = "../query-structure" } driver-adapters = { path = "../driver-adapters" } napi.workspace = true napi-derive.workspace = true diff --git a/query-engine/query-engine-wasm/Cargo.toml b/query-engine/query-engine-wasm/Cargo.toml index fdccc773eaf..60da1c11c6d 100644 --- a/query-engine/query-engine-wasm/Cargo.toml +++ b/query-engine/query-engine-wasm/Cargo.toml @@ -6,14 +6,14 @@ edition = "2021" [lib] doc = false crate-type = ["cdylib"] -name = "query_engine" +name = "query_engine_wasm" [dependencies] anyhow = "1" async-trait = "0.1" user-facing-errors = { path = "../../libs/user-facing-errors" } psl.workspace = true -prisma-models = { path = "../prisma-models" } +query-structure = { path = "../query-structure" } quaint = { path = "../../quaint" } request-handlers = { path = "../request-handlers", default-features = false, features = [ "sql", diff --git a/query-engine/query-engine-wasm/example.js b/query-engine/query-engine-wasm/example.js index bca6d5ba95d..6d3a78374bc 100644 --- a/query-engine/query-engine-wasm/example.js +++ b/query-engine/query-engine-wasm/example.js @@ -6,7 +6,7 @@ import { Pool } from '@neondatabase/serverless' import { PrismaNeon } from '@prisma/adapter-neon' import { bindAdapter } from '@prisma/driver-adapter-utils' -import { init, QueryEngine, getBuildTimeInfo } from './pkg/query_engine.js' +import { init, QueryEngine, getBuildTimeInfo } from './pkg/query_engine_wasm.js' async function main() { // Always initialize the Wasm library before using it. diff --git a/query-engine/query-engine-wasm/package.json b/query-engine/query-engine-wasm/package.json index 102db2ce14b..8192656bd56 100644 --- a/query-engine/query-engine-wasm/package.json +++ b/query-engine/query-engine-wasm/package.json @@ -1,9 +1,12 @@ { "type": "module", "main": "./example.js", + "scripts": { + "dev": "node --experimental-wasm-modules ./example.js" + }, "dependencies": { "@neondatabase/serverless": "0.6.0", - "@prisma/adapter-neon": "5.5.2", - "@prisma/driver-adapter-utils": "5.5.2" + "@prisma/adapter-neon": "5.6.0", + "@prisma/driver-adapter-utils": "5.6.0" } } diff --git a/query-engine/prisma-models/Cargo.toml b/query-engine/query-structure/Cargo.toml similarity index 96% rename from query-engine/prisma-models/Cargo.toml rename to query-engine/query-structure/Cargo.toml index 0becd1fdea7..db8cb68aaf8 100644 --- a/query-engine/prisma-models/Cargo.toml +++ b/query-engine/query-structure/Cargo.toml @@ -1,6 +1,6 @@ [package] edition = "2021" -name = "prisma-models" +name = "query-structure" version = "0.0.0" [dependencies] diff --git a/query-engine/prisma-models/src/composite_type.rs b/query-engine/query-structure/src/composite_type.rs similarity index 100% rename from query-engine/prisma-models/src/composite_type.rs rename to query-engine/query-structure/src/composite_type.rs diff --git a/query-engine/prisma-models/src/convert.rs b/query-engine/query-structure/src/convert.rs similarity index 100% rename from query-engine/prisma-models/src/convert.rs rename to query-engine/query-structure/src/convert.rs diff --git a/query-engine/prisma-models/src/default_value.rs b/query-engine/query-structure/src/default_value.rs similarity index 100% rename from query-engine/prisma-models/src/default_value.rs rename to query-engine/query-structure/src/default_value.rs diff --git a/query-engine/prisma-models/src/error.rs b/query-engine/query-structure/src/error.rs similarity index 100% rename from query-engine/prisma-models/src/error.rs rename to query-engine/query-structure/src/error.rs diff --git a/query-engine/prisma-models/src/field/composite.rs b/query-engine/query-structure/src/field/composite.rs similarity index 100% rename from query-engine/prisma-models/src/field/composite.rs rename to query-engine/query-structure/src/field/composite.rs diff --git a/query-engine/prisma-models/src/field/mod.rs b/query-engine/query-structure/src/field/mod.rs similarity index 100% rename from query-engine/prisma-models/src/field/mod.rs rename to query-engine/query-structure/src/field/mod.rs diff --git a/query-engine/prisma-models/src/field/relation.rs b/query-engine/query-structure/src/field/relation.rs similarity index 100% rename from query-engine/prisma-models/src/field/relation.rs rename to query-engine/query-structure/src/field/relation.rs diff --git a/query-engine/prisma-models/src/field/scalar.rs b/query-engine/query-structure/src/field/scalar.rs similarity index 100% rename from query-engine/prisma-models/src/field/scalar.rs rename to query-engine/query-structure/src/field/scalar.rs diff --git a/query-engine/prisma-models/src/field_selection.rs b/query-engine/query-structure/src/field_selection.rs similarity index 100% rename from query-engine/prisma-models/src/field_selection.rs rename to query-engine/query-structure/src/field_selection.rs diff --git a/query-engine/prisma-models/src/fields.rs b/query-engine/query-structure/src/fields.rs similarity index 100% rename from query-engine/prisma-models/src/fields.rs rename to query-engine/query-structure/src/fields.rs diff --git a/query-engine/connectors/query-connector/src/compare.rs b/query-engine/query-structure/src/filter/compare.rs similarity index 99% rename from query-engine/connectors/query-connector/src/compare.rs rename to query-engine/query-structure/src/filter/compare.rs index 783d847939c..7757965050a 100644 --- a/query-engine/connectors/query-connector/src/compare.rs +++ b/query-engine/query-structure/src/filter/compare.rs @@ -1,7 +1,7 @@ use super::*; use crate::filter::Filter; -use prisma_models::PrismaValue; +use prisma_value::PrismaValue; /// Comparing methods for scalar fields. pub trait ScalarCompare { diff --git a/query-engine/connectors/query-connector/src/filter/composite.rs b/query-engine/query-structure/src/filter/composite.rs similarity index 95% rename from query-engine/connectors/query-connector/src/filter/composite.rs rename to query-engine/query-structure/src/filter/composite.rs index cb113e9c035..d231421c325 100644 --- a/query-engine/connectors/query-connector/src/filter/composite.rs +++ b/query-engine/query-structure/src/filter/composite.rs @@ -1,7 +1,5 @@ -use crate::compare::CompositeCompare; -use crate::filter::Filter; -use prisma_models::{CompositeFieldRef, PrismaValue}; -// use std::sync::Arc; +use crate::{filter::Filter, CompositeCompare, CompositeFieldRef}; +use prisma_value::PrismaValue; #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct CompositeFilter { diff --git a/query-engine/connectors/query-connector/src/filter/into_filter.rs b/query-engine/query-structure/src/filter/into_filter.rs similarity index 93% rename from query-engine/connectors/query-connector/src/filter/into_filter.rs rename to query-engine/query-structure/src/filter/into_filter.rs index d2c32782795..b180b3b80c4 100644 --- a/query-engine/connectors/query-connector/src/filter/into_filter.rs +++ b/query-engine/query-structure/src/filter/into_filter.rs @@ -1,6 +1,7 @@ use super::*; + use crate::ScalarCompare; -use prisma_models::{SelectedField, SelectionResult}; +use crate::{SelectedField, SelectionResult}; pub trait IntoFilter { fn filter(self) -> Filter; diff --git a/query-engine/connectors/query-connector/src/filter/json.rs b/query-engine/query-structure/src/filter/json.rs similarity index 98% rename from query-engine/connectors/query-connector/src/filter/json.rs rename to query-engine/query-structure/src/filter/json.rs index c1cae9b8187..b0452106d19 100644 --- a/query-engine/connectors/query-connector/src/filter/json.rs +++ b/query-engine/query-structure/src/filter/json.rs @@ -1,6 +1,5 @@ use super::scalar::*; -use crate::{Filter, JsonCompare, ScalarFilter}; -use prisma_models::ScalarFieldRef; +use crate::{Filter, JsonCompare, ScalarFieldRef, ScalarFilter}; #[derive(Debug, Clone, Eq, Hash, PartialEq)] pub enum JsonTargetType { diff --git a/query-engine/connectors/query-connector/src/filter/list.rs b/query-engine/query-structure/src/filter/list.rs similarity index 96% rename from query-engine/connectors/query-connector/src/filter/list.rs rename to query-engine/query-structure/src/filter/list.rs index ab1cf913880..e71064c6709 100644 --- a/query-engine/connectors/query-connector/src/filter/list.rs +++ b/query-engine/query-structure/src/filter/list.rs @@ -1,6 +1,5 @@ use super::*; -use crate::compare::ScalarListCompare; -use prisma_models::{ScalarField, ScalarFieldRef}; +use crate::{ScalarField, ScalarFieldRef, ScalarListCompare}; #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ScalarListFilter { diff --git a/query-engine/connectors/query-connector/src/filter/mod.rs b/query-engine/query-structure/src/filter/mod.rs similarity index 99% rename from query-engine/connectors/query-connector/src/filter/mod.rs rename to query-engine/query-structure/src/filter/mod.rs index 856fb5207f9..a05d3e9c409 100644 --- a/query-engine/connectors/query-connector/src/filter/mod.rs +++ b/query-engine/query-structure/src/filter/mod.rs @@ -5,6 +5,7 @@ //! [RelationCompare](/query-connector/trait.RelationCompare.html). //! [CompositeCompare](/query-connector/trait.RelationCompare.html). +mod compare; mod composite; mod into_filter; mod json; @@ -12,14 +13,16 @@ mod list; mod relation; mod scalar; +pub use compare::*; pub use composite::*; pub use into_filter::*; pub use json::*; pub use list::*; -use prisma_models::ScalarFieldRef; pub use relation::*; pub use scalar::*; +use crate::ScalarFieldRef; + #[derive(Debug, Clone, Eq, Hash, PartialEq)] pub enum Filter { And(Vec), diff --git a/query-engine/connectors/query-connector/src/filter/relation.rs b/query-engine/query-structure/src/filter/relation.rs similarity index 97% rename from query-engine/connectors/query-connector/src/filter/relation.rs rename to query-engine/query-structure/src/filter/relation.rs index 500e406e407..d806ba2dec1 100644 --- a/query-engine/connectors/query-connector/src/filter/relation.rs +++ b/query-engine/query-structure/src/filter/relation.rs @@ -1,6 +1,4 @@ -use crate::compare::RelationCompare; -use crate::filter::Filter; -use prisma_models::RelationField; +use crate::{filter::Filter, RelationCompare, RelationField}; #[derive(Clone, PartialEq, Eq, Hash)] pub struct RelationFilter { diff --git a/query-engine/connectors/query-connector/src/filter/scalar/compare.rs b/query-engine/query-structure/src/filter/scalar/compare.rs similarity index 99% rename from query-engine/connectors/query-connector/src/filter/scalar/compare.rs rename to query-engine/query-structure/src/filter/scalar/compare.rs index f9379844102..efbbb370f66 100644 --- a/query-engine/connectors/query-connector/src/filter/scalar/compare.rs +++ b/query-engine/query-structure/src/filter/scalar/compare.rs @@ -1,6 +1,5 @@ use super::*; use crate::*; -use prisma_models::*; impl ScalarCompare for ScalarFieldRef { /// Field is in a given value diff --git a/query-engine/connectors/query-connector/src/filter/scalar/condition/mod.rs b/query-engine/query-structure/src/filter/scalar/condition/mod.rs similarity index 99% rename from query-engine/connectors/query-connector/src/filter/scalar/condition/mod.rs rename to query-engine/query-structure/src/filter/scalar/condition/mod.rs index 4845fab126f..ff32d3d5221 100644 --- a/query-engine/connectors/query-connector/src/filter/scalar/condition/mod.rs +++ b/query-engine/query-structure/src/filter/scalar/condition/mod.rs @@ -4,7 +4,6 @@ pub use value::{ConditionListValue, ConditionValue}; use super::*; use crate::*; -use prisma_models::*; #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum ScalarCondition { diff --git a/query-engine/connectors/query-connector/src/filter/scalar/condition/value.rs b/query-engine/query-structure/src/filter/scalar/condition/value.rs similarity index 97% rename from query-engine/connectors/query-connector/src/filter/scalar/condition/value.rs rename to query-engine/query-structure/src/filter/scalar/condition/value.rs index a93a8e304ad..5a1b7b7aecb 100644 --- a/query-engine/connectors/query-connector/src/filter/scalar/condition/value.rs +++ b/query-engine/query-structure/src/filter/scalar/condition/value.rs @@ -1,4 +1,5 @@ -use prisma_models::{PrismaListValue, PrismaValue, ScalarFieldRef}; +use crate::field::*; +use prisma_value::{PrismaListValue, PrismaValue}; #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum ConditionValue { diff --git a/query-engine/connectors/query-connector/src/filter/scalar/mod.rs b/query-engine/query-structure/src/filter/scalar/mod.rs similarity index 99% rename from query-engine/connectors/query-connector/src/filter/scalar/mod.rs rename to query-engine/query-structure/src/filter/scalar/mod.rs index a2179b758b2..adc2cc6de32 100644 --- a/query-engine/connectors/query-connector/src/filter/scalar/mod.rs +++ b/query-engine/query-structure/src/filter/scalar/mod.rs @@ -6,7 +6,7 @@ pub use compare::*; pub use condition::*; pub use projection::*; -use prisma_models::*; +use crate::*; use std::collections::BTreeSet; diff --git a/query-engine/connectors/query-connector/src/filter/scalar/projection.rs b/query-engine/query-structure/src/filter/scalar/projection.rs similarity index 97% rename from query-engine/connectors/query-connector/src/filter/scalar/projection.rs rename to query-engine/query-structure/src/filter/scalar/projection.rs index 63170be55e5..799ab0859cb 100644 --- a/query-engine/connectors/query-connector/src/filter/scalar/projection.rs +++ b/query-engine/query-structure/src/filter/scalar/projection.rs @@ -1,4 +1,4 @@ -use prisma_models::ScalarFieldRef; +use crate::field::ScalarFieldRef; #[derive(Clone, PartialEq, Eq, Hash)] pub enum ScalarProjection { diff --git a/query-engine/prisma-models/src/internal_data_model.rs b/query-engine/query-structure/src/internal_data_model.rs similarity index 100% rename from query-engine/prisma-models/src/internal_data_model.rs rename to query-engine/query-structure/src/internal_data_model.rs diff --git a/query-engine/prisma-models/src/internal_enum.rs b/query-engine/query-structure/src/internal_enum.rs similarity index 100% rename from query-engine/prisma-models/src/internal_enum.rs rename to query-engine/query-structure/src/internal_enum.rs diff --git a/query-engine/prisma-models/src/lib.rs b/query-engine/query-structure/src/lib.rs similarity index 91% rename from query-engine/prisma-models/src/lib.rs rename to query-engine/query-structure/src/lib.rs index 87bdacfb8ce..25519a6d856 100644 --- a/query-engine/prisma-models/src/lib.rs +++ b/query-engine/query-structure/src/lib.rs @@ -13,11 +13,13 @@ mod order_by; mod parent_container; mod prisma_value_ext; mod projections; +mod query_arguments; mod record; mod relation; mod selection_result; mod zipper; +pub mod filter; pub mod prelude; pub use self::{default_value::*, native_type_instance::*, zipper::*}; @@ -27,11 +29,13 @@ pub use error::*; pub use field::*; pub use field_selection::*; pub use fields::*; +pub use filter::*; pub use internal_data_model::*; pub use internal_enum::*; pub use model::*; pub use order_by::*; pub use projections::*; +pub use query_arguments::*; pub use record::*; pub use relation::*; pub use selection_result::*; diff --git a/query-engine/prisma-models/src/model.rs b/query-engine/query-structure/src/model.rs similarity index 100% rename from query-engine/prisma-models/src/model.rs rename to query-engine/query-structure/src/model.rs diff --git a/query-engine/prisma-models/src/native_type_instance.rs b/query-engine/query-structure/src/native_type_instance.rs similarity index 100% rename from query-engine/prisma-models/src/native_type_instance.rs rename to query-engine/query-structure/src/native_type_instance.rs diff --git a/query-engine/prisma-models/src/order_by.rs b/query-engine/query-structure/src/order_by.rs similarity index 100% rename from query-engine/prisma-models/src/order_by.rs rename to query-engine/query-structure/src/order_by.rs diff --git a/query-engine/prisma-models/src/parent_container.rs b/query-engine/query-structure/src/parent_container.rs similarity index 100% rename from query-engine/prisma-models/src/parent_container.rs rename to query-engine/query-structure/src/parent_container.rs diff --git a/query-engine/prisma-models/src/prelude.rs b/query-engine/query-structure/src/prelude.rs similarity index 100% rename from query-engine/prisma-models/src/prelude.rs rename to query-engine/query-structure/src/prelude.rs diff --git a/query-engine/prisma-models/src/prisma_value_ext.rs b/query-engine/query-structure/src/prisma_value_ext.rs similarity index 100% rename from query-engine/prisma-models/src/prisma_value_ext.rs rename to query-engine/query-structure/src/prisma_value_ext.rs diff --git a/query-engine/prisma-models/src/projections/mod.rs b/query-engine/query-structure/src/projections/mod.rs similarity index 100% rename from query-engine/prisma-models/src/projections/mod.rs rename to query-engine/query-structure/src/projections/mod.rs diff --git a/query-engine/prisma-models/src/projections/model_projection.rs b/query-engine/query-structure/src/projections/model_projection.rs similarity index 100% rename from query-engine/prisma-models/src/projections/model_projection.rs rename to query-engine/query-structure/src/projections/model_projection.rs diff --git a/query-engine/connectors/query-connector/src/query_arguments.rs b/query-engine/query-structure/src/query_arguments.rs similarity index 99% rename from query-engine/connectors/query-connector/src/query_arguments.rs rename to query-engine/query-structure/src/query_arguments.rs index cb9e5509734..f9c222d80db 100644 --- a/query-engine/connectors/query-connector/src/query_arguments.rs +++ b/query-engine/query-structure/src/query_arguments.rs @@ -1,5 +1,4 @@ -use crate::filter::Filter; -use prisma_models::*; +use crate::*; /// `QueryArguments` define various constraints queried data should fulfill: /// - `cursor`, `take`, `skip` page through the data. diff --git a/query-engine/prisma-models/src/record.rs b/query-engine/query-structure/src/record.rs similarity index 100% rename from query-engine/prisma-models/src/record.rs rename to query-engine/query-structure/src/record.rs diff --git a/query-engine/prisma-models/src/relation.rs b/query-engine/query-structure/src/relation.rs similarity index 100% rename from query-engine/prisma-models/src/relation.rs rename to query-engine/query-structure/src/relation.rs diff --git a/query-engine/prisma-models/src/selection_result.rs b/query-engine/query-structure/src/selection_result.rs similarity index 100% rename from query-engine/prisma-models/src/selection_result.rs rename to query-engine/query-structure/src/selection_result.rs diff --git a/query-engine/prisma-models/src/zipper.rs b/query-engine/query-structure/src/zipper.rs similarity index 100% rename from query-engine/prisma-models/src/zipper.rs rename to query-engine/query-structure/src/zipper.rs diff --git a/query-engine/prisma-models/tests/datamodel_converter_tests.rs b/query-engine/query-structure/tests/datamodel_converter_tests.rs similarity index 99% rename from query-engine/prisma-models/tests/datamodel_converter_tests.rs rename to query-engine/query-structure/tests/datamodel_converter_tests.rs index a2ee28ca6c0..c7ef83e0617 100644 --- a/query-engine/prisma-models/tests/datamodel_converter_tests.rs +++ b/query-engine/query-structure/tests/datamodel_converter_tests.rs @@ -1,6 +1,6 @@ #![allow(non_snake_case)] -use prisma_models::*; +use query_structure::*; use std::sync::Arc; #[test] @@ -420,7 +420,7 @@ fn duplicate_relation_name() { fn convert(datamodel: &str) -> InternalDataModel { let schema = psl::parse_schema(datamodel).unwrap(); - prisma_models::convert(Arc::new(schema)) + query_structure::convert(Arc::new(schema)) } trait DatamodelAssertions { diff --git a/query-engine/request-handlers/Cargo.toml b/query-engine/request-handlers/Cargo.toml index f04d742c448..51ed4bd8b5a 100644 --- a/query-engine/request-handlers/Cargo.toml +++ b/query-engine/request-handlers/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" edition = "2021" [dependencies] -prisma-models = { path = "../prisma-models" } +query-structure = { path = "../query-structure" } query-core = { path = "../core" } user-facing-errors = { path = "../../libs/user-facing-errors" } quaint = { path = "../../quaint" } diff --git a/query-engine/request-handlers/src/handler.rs b/query-engine/request-handlers/src/handler.rs index df25616c220..cd5d887718f 100644 --- a/query-engine/request-handlers/src/handler.rs +++ b/query-engine/request-handlers/src/handler.rs @@ -2,7 +2,6 @@ use super::GQLResponse; use crate::{GQLError, PrismaResponse, RequestBody}; use futures::FutureExt; use indexmap::IndexMap; -use prisma_models::{parse_datetime, stringify_datetime, PrismaValue}; use query_core::{ constants::custom_types, protocol::EngineProtocol, @@ -11,6 +10,7 @@ use query_core::{ ArgumentValue, ArgumentValueObject, BatchDocument, BatchDocumentTransaction, CompactedDocument, Operation, QueryDocument, QueryExecutor, TxId, }; +use query_structure::{parse_datetime, stringify_datetime, PrismaValue}; use std::{collections::HashMap, fmt, panic::AssertUnwindSafe}; type ArgsToResult = (HashMap, IndexMap); diff --git a/query-engine/request-handlers/src/protocols/json/protocol_adapter.rs b/query-engine/request-handlers/src/protocols/json/protocol_adapter.rs index 208705268c1..09ceeae20c0 100644 --- a/query-engine/request-handlers/src/protocols/json/protocol_adapter.rs +++ b/query-engine/request-handlers/src/protocols/json/protocol_adapter.rs @@ -1,12 +1,12 @@ use crate::{FieldQuery, HandlerError, JsonSingleQuery, SelectionSet}; use bigdecimal::{BigDecimal, FromPrimitive}; use indexmap::IndexMap; -use prisma_models::{decode_bytes, parse_datetime, prelude::ParentContainer, Field}; use query_core::{ constants::custom_types, schema::{ObjectType, OutputField, QuerySchema}, ArgumentValue, Operation, Selection, }; +use query_structure::{decode_bytes, parse_datetime, prelude::ParentContainer, Field}; use serde_json::Value as JsonValue; use std::str::FromStr; diff --git a/query-engine/schema/Cargo.toml b/query-engine/schema/Cargo.toml index 0d4c06ad944..12664344572 100644 --- a/query-engine/schema/Cargo.toml +++ b/query-engine/schema/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" edition = "2021" [dependencies] -prisma-models = { path = "../prisma-models" } +query-structure = { path = "../query-structure" } psl.workspace = true rustc-hash = "1.1.0" once_cell = "1" diff --git a/query-engine/schema/README.md b/query-engine/schema/README.md index 4952270b0cd..9522bdd563a 100644 --- a/query-engine/schema/README.md +++ b/query-engine/schema/README.md @@ -1,6 +1,6 @@ # schema -This crate contains the logic responsible for building a query schema from a Prisma datamodel (presented as a `prisma_models::InternalDataModel`). +This crate contains the logic responsible for building a query schema from a Prisma datamodel (presented as a `query_structure::InternalDataModel`). ## Benchmarks diff --git a/query-engine/schema/src/build.rs b/query-engine/schema/src/build.rs index 6fa03c3fabb..3c589989f21 100644 --- a/query-engine/schema/src/build.rs +++ b/query-engine/schema/src/build.rs @@ -15,8 +15,8 @@ pub(crate) use output_types::{mutation_type, query_type}; use self::{enum_types::*, utils::*}; use crate::*; -use prisma_models::{ast, Field as ModelField, Model, RelationFieldRef, TypeIdentifier}; use psl::{datamodel_connector::ConnectorCapability, PreviewFeatures}; +use query_structure::{ast, Field as ModelField, Model, RelationFieldRef, TypeIdentifier}; pub fn build(schema: Arc, enable_raw_queries: bool) -> QuerySchema { let preview_features = schema.configuration.preview_features(); @@ -29,6 +29,6 @@ pub fn build_with_features( enable_raw_queries: bool, ) -> QuerySchema { let connector = schema.connector; - let internal_data_model = prisma_models::convert(schema); + let internal_data_model = query_structure::convert(schema); QuerySchema::new(enable_raw_queries, connector, preview_features, internal_data_model) } diff --git a/query-engine/schema/src/build/enum_types.rs b/query-engine/schema/src/build/enum_types.rs index 715a161b08b..48490ccc914 100644 --- a/query-engine/schema/src/build/enum_types.rs +++ b/query-engine/schema/src/build/enum_types.rs @@ -1,7 +1,7 @@ use super::*; use crate::EnumType; use constants::{filters, itx, json_null, ordering}; -use prisma_models::prelude::ParentContainer; +use query_structure::prelude::ParentContainer; pub(crate) fn sort_order_enum() -> EnumType { let ident = Identifier::new_prisma(IdentifierType::SortOrder); diff --git a/query-engine/schema/src/build/input_types/fields/arguments.rs b/query-engine/schema/src/build/input_types/fields/arguments.rs index 33400b7d000..58393083f7f 100644 --- a/query-engine/schema/src/build/input_types/fields/arguments.rs +++ b/query-engine/schema/src/build/input_types/fields/arguments.rs @@ -3,7 +3,7 @@ use constants::args; use input_types::objects::order_by_objects::OrderByOptions; use mutations::create_one; use objects::*; -use prisma_models::{prelude::ParentContainer, CompositeFieldRef}; +use query_structure::{prelude::ParentContainer, CompositeFieldRef}; /// Builds "where" argument. pub(crate) fn where_argument<'a>(ctx: &'a QuerySchema, model: &Model) -> InputField<'a> { diff --git a/query-engine/schema/src/build/input_types/fields/data_input_mapper/create.rs b/query-engine/schema/src/build/input_types/fields/data_input_mapper/create.rs index 5f00ee47c65..d952cb0d18d 100644 --- a/query-engine/schema/src/build/input_types/fields/data_input_mapper/create.rs +++ b/query-engine/schema/src/build/input_types/fields/data_input_mapper/create.rs @@ -1,6 +1,6 @@ use super::*; use constants::*; -use prisma_models::CompositeFieldRef; +use query_structure::CompositeFieldRef; pub(crate) struct CreateDataInputFieldMapper { unchecked: bool, diff --git a/query-engine/schema/src/build/input_types/fields/data_input_mapper/mod.rs b/query-engine/schema/src/build/input_types/fields/data_input_mapper/mod.rs index 91ae1532268..b8269875527 100644 --- a/query-engine/schema/src/build/input_types/fields/data_input_mapper/mod.rs +++ b/query-engine/schema/src/build/input_types/fields/data_input_mapper/mod.rs @@ -5,7 +5,7 @@ pub(crate) use create::*; pub(crate) use update::*; use super::*; -use prisma_models::prelude::*; +use query_structure::prelude::*; // Todo: This isn't final, this is only the first draft to get structure into the // wild cross-dependency waste that was the create/update inputs. diff --git a/query-engine/schema/src/build/input_types/fields/data_input_mapper/update.rs b/query-engine/schema/src/build/input_types/fields/data_input_mapper/update.rs index a9b0395d2e0..e6f051b7058 100644 --- a/query-engine/schema/src/build/input_types/fields/data_input_mapper/update.rs +++ b/query-engine/schema/src/build/input_types/fields/data_input_mapper/update.rs @@ -1,6 +1,6 @@ use super::*; use constants::*; -use prisma_models::CompositeFieldRef; +use query_structure::CompositeFieldRef; pub(crate) struct UpdateDataInputFieldMapper { unchecked: bool, diff --git a/query-engine/schema/src/build/input_types/fields/field_filter_types.rs b/query-engine/schema/src/build/input_types/fields/field_filter_types.rs index af2c77d006b..84e6faa749e 100644 --- a/query-engine/schema/src/build/input_types/fields/field_filter_types.rs +++ b/query-engine/schema/src/build/input_types/fields/field_filter_types.rs @@ -1,7 +1,7 @@ use super::{field_ref_type::WithFieldRefInputExt, objects::*, *}; use constants::{aggregations, filters}; -use prisma_models::{CompositeFieldRef, DefaultKind, NativeTypeInstance, PrismaValue}; use psl::datamodel_connector::ConnectorCapability; +use query_structure::{CompositeFieldRef, DefaultKind, NativeTypeInstance, PrismaValue}; /// Builds filter types for the given model field. pub(crate) fn get_field_filter_types( diff --git a/query-engine/schema/src/build/input_types/mod.rs b/query-engine/schema/src/build/input_types/mod.rs index 98c8caa84a3..14ff37722d6 100644 --- a/query-engine/schema/src/build/input_types/mod.rs +++ b/query-engine/schema/src/build/input_types/mod.rs @@ -3,7 +3,7 @@ pub(crate) mod objects; use super::*; use fields::*; -use prisma_models::ScalarFieldRef; +use query_structure::ScalarFieldRef; fn map_scalar_input_type_for_field<'a>(ctx: &'a QuerySchema, field: &ScalarFieldRef) -> InputType<'a> { map_scalar_input_type(ctx, field.type_identifier(), field.is_list()) diff --git a/query-engine/schema/src/build/input_types/objects/filter_objects.rs b/query-engine/schema/src/build/input_types/objects/filter_objects.rs index 0ea555f7772..6ae66ca4219 100644 --- a/query-engine/schema/src/build/input_types/objects/filter_objects.rs +++ b/query-engine/schema/src/build/input_types/objects/filter_objects.rs @@ -1,6 +1,6 @@ use super::*; use constants::filters; -use prisma_models::{prelude::ParentContainer, CompositeFieldRef}; +use query_structure::{prelude::ParentContainer, CompositeFieldRef}; pub(crate) fn scalar_filter_object_type( ctx: &'_ QuerySchema, diff --git a/query-engine/schema/src/build/input_types/objects/order_by_objects.rs b/query-engine/schema/src/build/input_types/objects/order_by_objects.rs index e5112c5c71f..b36670f053d 100644 --- a/query-engine/schema/src/build/input_types/objects/order_by_objects.rs +++ b/query-engine/schema/src/build/input_types/objects/order_by_objects.rs @@ -3,7 +3,7 @@ use std::borrow::Cow; use super::*; use constants::{aggregations, ordering}; use output_types::aggregation; -use prisma_models::prelude::ParentContainer; +use query_structure::prelude::ParentContainer; #[derive(Debug, Default, Clone, Copy)] pub(crate) struct OrderByOptions { diff --git a/query-engine/schema/src/build/mutations/create_many.rs b/query-engine/schema/src/build/mutations/create_many.rs index c96314e90a1..9ef94df2624 100644 --- a/query-engine/schema/src/build/mutations/create_many.rs +++ b/query-engine/schema/src/build/mutations/create_many.rs @@ -3,8 +3,8 @@ use crate::{Identifier, IdentifierType, InputField, InputType, OutputField, Outp use constants::*; use input_types::{fields::data_input_mapper::*, list_union_type}; use output_types::objects; -use prisma_models::{Model, RelationFieldRef}; use psl::datamodel_connector::ConnectorCapability; +use query_structure::{Model, RelationFieldRef}; /// Builds a create many mutation field (e.g. createManyUsers) for given model. pub(crate) fn create_many(ctx: &'_ QuerySchema, model: Model) -> OutputField<'_> { diff --git a/query-engine/schema/src/build/mutations/create_one.rs b/query-engine/schema/src/build/mutations/create_one.rs index 0452e488501..11699c7cce1 100644 --- a/query-engine/schema/src/build/mutations/create_one.rs +++ b/query-engine/schema/src/build/mutations/create_one.rs @@ -5,7 +5,7 @@ use crate::{ use constants::*; use input_types::fields::data_input_mapper::*; use output_types::objects; -use prisma_models::{Model, RelationFieldRef}; +use query_structure::{Model, RelationFieldRef}; /// Builds a create mutation field (e.g. createUser) for given model. pub(crate) fn create_one(ctx: &QuerySchema, model: Model) -> OutputField<'_> { diff --git a/query-engine/schema/src/build/output_types/aggregation/mod.rs b/query-engine/schema/src/build/output_types/aggregation/mod.rs index 30db9edca67..4b3043c6c80 100644 --- a/query-engine/schema/src/build/output_types/aggregation/mod.rs +++ b/query-engine/schema/src/build/output_types/aggregation/mod.rs @@ -1,5 +1,5 @@ use super::*; -use prisma_models::{prelude::ParentContainer, ScalarField}; +use query_structure::{prelude::ParentContainer, ScalarField}; pub(crate) mod group_by; pub(crate) mod plain; diff --git a/query-engine/schema/src/build/output_types/field.rs b/query-engine/schema/src/build/output_types/field.rs index 2fb5bce366d..29924c9d98c 100644 --- a/query-engine/schema/src/build/output_types/field.rs +++ b/query-engine/schema/src/build/output_types/field.rs @@ -1,6 +1,6 @@ use super::*; use input_types::fields::arguments; -use prisma_models::{CompositeFieldRef, ScalarFieldRef}; +use query_structure::{CompositeFieldRef, ScalarFieldRef}; pub(crate) fn map_output_field(ctx: &'_ QuerySchema, model_field: ModelField) -> OutputField<'_> { let cloned_model_field = model_field.clone(); diff --git a/query-engine/schema/src/build/output_types/mutation_type.rs b/query-engine/schema/src/build/output_types/mutation_type.rs index 6aff5185de7..b0202360acb 100644 --- a/query-engine/schema/src/build/output_types/mutation_type.rs +++ b/query-engine/schema/src/build/output_types/mutation_type.rs @@ -1,8 +1,8 @@ use super::*; use input_types::fields::arguments; use mutations::{create_many, create_one}; -use prisma_models::{DefaultKind, PrismaValue}; use psl::datamodel_connector::ConnectorCapability; +use query_structure::{DefaultKind, PrismaValue}; /// Builds the root `Mutation` type. pub(crate) fn mutation_fields(ctx: &QuerySchema) -> Vec { diff --git a/query-engine/schema/src/build/output_types/objects/composite.rs b/query-engine/schema/src/build/output_types/objects/composite.rs index f52d25de3c1..ca64cdaaaa5 100644 --- a/query-engine/schema/src/build/output_types/objects/composite.rs +++ b/query-engine/schema/src/build/output_types/objects/composite.rs @@ -1,7 +1,7 @@ #![allow(clippy::unnecessary_to_owned)] use super::*; -use prisma_models::CompositeType; +use query_structure::CompositeType; pub(crate) fn composite_object_type(ctx: &'_ QuerySchema, composite: CompositeType) -> ObjectType<'_> { ObjectType::new(Identifier::new_model(composite.name().to_owned()), move || { diff --git a/query-engine/schema/src/build/utils.rs b/query-engine/schema/src/build/utils.rs index 4eeafcb23c8..d7ee3106d23 100644 --- a/query-engine/schema/src/build/utils.rs +++ b/query-engine/schema/src/build/utils.rs @@ -1,6 +1,6 @@ use super::*; use once_cell::sync::Lazy; -use prisma_models::{walkers, DefaultKind}; +use query_structure::{walkers, DefaultKind}; use std::borrow::Cow; /// Input object type convenience wrapper function. diff --git a/query-engine/schema/src/enum_type.rs b/query-engine/schema/src/enum_type.rs index b9225b30cd1..7529e95d27d 100644 --- a/query-engine/schema/src/enum_type.rs +++ b/query-engine/schema/src/enum_type.rs @@ -1,5 +1,5 @@ use super::*; -use prisma_models::{InternalEnum, PrismaValue, ScalarFieldRef}; +use query_structure::{InternalEnum, PrismaValue, ScalarFieldRef}; #[derive(Debug, Clone, PartialEq)] pub enum EnumType { diff --git a/query-engine/schema/src/identifier_type.rs b/query-engine/schema/src/identifier_type.rs index 0d24efc0cc5..825a8dd741c 100644 --- a/query-engine/schema/src/identifier_type.rs +++ b/query-engine/schema/src/identifier_type.rs @@ -1,5 +1,5 @@ use crate::{capitalize, constants::ordering, scalar_filter_name}; -use prisma_models::{ast::FieldArity, prelude::*, *}; +use query_structure::{ast::FieldArity, prelude::*, *}; /// Enum used to represent unique schema type names. /// It helps deferring the allocation + formatting of strings diff --git a/query-engine/schema/src/input_types.rs b/query-engine/schema/src/input_types.rs index 176a31a60a1..3a6c0610f60 100644 --- a/query-engine/schema/src/input_types.rs +++ b/query-engine/schema/src/input_types.rs @@ -1,7 +1,7 @@ use super::*; use fmt::Debug; use once_cell::sync::Lazy; -use prisma_models::{prelude::ParentContainer, DefaultKind}; +use query_structure::{prelude::ParentContainer, DefaultKind}; use std::{borrow::Cow, boxed::Box, fmt}; type InputObjectFields<'a> = diff --git a/query-engine/schema/src/output_types.rs b/query-engine/schema/src/output_types.rs index 7aa949f7908..32956d01d50 100644 --- a/query-engine/schema/src/output_types.rs +++ b/query-engine/schema/src/output_types.rs @@ -1,7 +1,7 @@ use super::*; use fmt::Debug; use once_cell::sync::Lazy; -use prisma_models::ast::ModelId; +use query_structure::ast::ModelId; use std::{borrow::Cow, fmt}; #[derive(Debug, Clone)] diff --git a/query-engine/schema/src/query_schema.rs b/query-engine/schema/src/query_schema.rs index f48572db32f..0324896aea0 100644 --- a/query-engine/schema/src/query_schema.rs +++ b/query-engine/schema/src/query_schema.rs @@ -1,9 +1,9 @@ use crate::{IdentifierType, ObjectType, OutputField}; -use prisma_models::{ast, InternalDataModel}; use psl::{ datamodel_connector::{Connector, ConnectorCapabilities, ConnectorCapability, RelationMode}, PreviewFeature, PreviewFeatures, }; +use query_structure::{ast, InternalDataModel}; use std::{collections::HashMap, fmt}; #[derive(Clone, Debug, Hash, Eq, PartialEq)]