Add support for UUIDv7

Cargo.toml

@@ -52,7 +52,7 @@ tokio = { version = "1.25", features = [
 ] }
 chrono = { version = "0.4.38", features = ["serde"] }
 user-facing-errors = { path = "./libs/user-facing-errors" }
-uuid = { version = "1", features = ["serde", "v4"] }
+uuid = { version = "1", features = ["serde", "v4", "v7", "js"] }
 indoc = "2.0.1"
 indexmap = { version = "2.2.2", features = ["serde"] }
 itertools = "0.12"

psl/parser-database/src/attributes/default.rs

@@ -196,11 +196,12 @@ fn validate_model_builtin_scalar_type_default(
  {
  validate_empty_function_args(funcname, &funcargs.arguments, accept, ctx)
  }
- (ScalarType::String, ast::Expression::Function(funcname, funcargs, _))
- if funcname == FN_UUID || funcname == FN_CUID =>
- {
+ (ScalarType::String, ast::Expression::Function(funcname, funcargs, _)) if funcname == FN_CUID => {
  validate_empty_function_args(funcname, &funcargs.arguments, accept, ctx)
  }
+ (ScalarType::String, ast::Expression::Function(funcname, funcargs, _)) if funcname == FN_UUID => {
+ validate_uuid_args(&funcargs.arguments, accept, ctx)
+ }
  (ScalarType::String, ast::Expression::Function(funcname, funcargs, _)) if funcname == FN_NANOID => {
  validate_nanoid_args(&funcargs.arguments, accept, ctx)
  }
@@ -242,11 +243,12 @@ fn validate_composite_builtin_scalar_type_default(
 ) {
  match (scalar_type, value) {
  // Functions
- (ScalarType::String, ast::Expression::Function(funcname, funcargs, _))
- if funcname == FN_UUID || funcname == FN_CUID =>
- {
+ (ScalarType::String, ast::Expression::Function(funcname, funcargs, _)) if funcname == FN_CUID => {
  validate_empty_function_args(funcname, &funcargs.arguments, accept, ctx)
  }
+ (ScalarType::String, ast::Expression::Function(funcname, funcargs, _)) if funcname == FN_UUID => {
+ validate_uuid_args(&funcargs.arguments, accept, ctx)
+ }
  (ScalarType::DateTime, ast::Expression::Function(funcname, funcargs, _)) if funcname == FN_NOW => {
  validate_empty_function_args(FN_NOW, &funcargs.arguments, accept, ctx)
  }
@@ -379,6 +381,24 @@ fn validate_dbgenerated_args(args: &[ast::Argument], accept: AcceptFn<'_>, ctx:
  }
 }
 
+fn validate_uuid_args(args: &[ast::Argument], accept: AcceptFn<'_>, ctx: &mut Context<'_>) {
+ let mut bail = || ctx.push_attribute_validation_error("`uuid()` takes a single Int argument.");
+
+ if args.len() > 1 {
+ bail()
+ }
+
+ match args.first().map(|arg| &arg.value) {
+ Some(ast::Expression::NumericValue(val, _)) if ![4u8, 7u8].contains(&val.parse::<u8>().unwrap()) => {
+ ctx.push_attribute_validation_error(
+ "`uuid()` takes either no argument, or a single integer argument which is either 4 or 7.",
+ );
+ }
+ None | Some(ast::Expression::NumericValue(_, _)) => accept(ctx),
+ _ => bail(),
+ }
+}
+
 fn validate_nanoid_args(args: &[ast::Argument], accept: AcceptFn<'_>, ctx: &mut Context<'_>) {
  let mut bail = || ctx.push_attribute_validation_error("`nanoid()` takes a single Int argument.");
 

psl/psl/tests/attributes/id_negative.rs

@@ -44,6 +44,26 @@ fn id_should_error_multiple_ids_are_provided() {
  expect_error(dml, &expectation)
 }
 
+#[test]
+fn id_should_error_on_invalid_uuid_version() {
+ let dml = indoc! {r#"
+ model Model {
+ id String @id @default(uuid(1))
+ }
+ "#};
+
+ let expectation = expect![[r#"
+ error: Error parsing attribute "@default": `uuid()` takes either no argument, or a single integer argument which is either 4 or 7.
+ --> schema.prisma:2
+  | 
+  1 | model Model {
+  2 |  id String @id @default(uuid(1))
+  | 
+ "#]];
+
+ expect_error(dml, &expectation)
+}
+
 #[test]
 fn id_must_error_when_single_and_multi_field_id_is_used() {
  let dml = indoc! {r#"

psl/psl/tests/attributes/id_positive.rs

@@ -70,6 +70,45 @@ fn should_allow_string_ids_with_uuid() {
  model.assert_id_on_fields(&["id"]);
 }
 
+#[test]
+fn should_allow_string_ids_with_uuid_version_specified() {
+ let dml = indoc! {r#"
+ model ModelA {
+ id String @id @default(uuid(4))
+ }
+
+ model ModelB {
+ id String @id @default(uuid(7))
+ }
+ "#};
+
+ let schema = psl::parse_schema(dml).unwrap();
+
+ {
+ let model = schema.assert_has_model("ModelA");
+
+ model
+ .assert_has_scalar_field("id")
+ .assert_scalar_type(ScalarType::String)
+ .assert_default_value()
+ .assert_uuid();
+
+ model.assert_id_on_fields(&["id"]);
+ }
+
+ {
+ let model = schema.assert_has_model("ModelB");
+
+ model
+ .assert_has_scalar_field("id")
+ .assert_scalar_type(ScalarType::String)
+ .assert_default_value()
+ .assert_uuid();
+
+ model.assert_id_on_fields(&["id"]);
+ }
+}
+
 #[test]
 fn should_allow_string_ids_without_default() {
  let dml = indoc! {r#"

psl/psl/tests/common/asserts.rs

@@ -631,9 +631,7 @@ impl DefaultValueAssert for ast::Expression {
 
  #[track_caller]
  fn assert_uuid(&self) -> &Self {
- assert!(
- matches!(self, ast::Expression::Function(name, args, _) if name == "uuid" && args.arguments.is_empty())
- );
+ assert!(matches!(self, ast::Expression::Function(name, _, _) if name == "uuid"));
 
  self
  }

query-engine/connector-test-kit-rs/query-engine-tests/tests/writes/ids/uuid_create_graphql.rs

@@ -68,4 +68,66 @@ mod uuid_create_graphql {
 
  Ok(())
  }
+
+ fn schema_3() -> String {
+ let schema = indoc! {
+ r#"model Todo {
+ #id(id, String, @id, @default(uuid(7)))
+ title String
+ }"#
+ };
+
+ schema.to_owned()
+ }
+
+ // "Creating an item with an id field of model UUIDv7 and retrieving it" should "work"
+ #[connector_test(schema(schema_3))]
+ async fn create_uuid_v7_and_retrieve_it_should_work(runner: Runner) -> TestResult<()> {
+ let res = run_query_json!(
+ &runner,
+ r#"mutation {
+ createOneTodo(data: { title: "the title" }){
+ id
+ }
+ }"#
+ );
+
+ let uuid = match &res["data"]["createOneTodo"]["id"] {
+ serde_json::Value::String(str) => str,
+ _ => unreachable!(),
+ };
+
+ // Validate that this is a valid UUIDv7 value
+ {
+ let uuid = uuid::Uuid::parse_str(uuid.as_str()).expect("Expected valid UUID but couldn't parse it.");
+ assert_eq!(
+ uuid.get_version().expect("Expected UUIDv7 but got something else."),
+ uuid::Version::SortRand
+ );
+ }
+
+ // Test findMany
+ let res = run_query_json!(
+ &runner,
+ r#"query { findManyTodo(where: { title: "the title" }) { id }}"#
+ );
+ if let serde_json::Value::String(str) = &res["data"]["findManyTodo"][0]["id"] {
+ assert_eq!(str, uuid);
+ } else {
+ panic!("Expected UUID but got something else.");
+ }
+
+ // Test findUnique
+ let res = run_query_json!(
+ &runner,
+ format!(r#"query {{ findUniqueTodo(where: {{ id: "{}" }}) {{ id }} }}"#, uuid)
+ );
+ if let serde_json::Value::String(str) = &res["data"]["findUniqueTodo"]["id"] {
+ assert_eq!(str, uuid);
+ } else {
+ panic!("Expected UUID but got something else.");
+ }
+
+ Ok(())
+ }
 }

query-engine/query-structure/Cargo.toml

@@ -22,4 +22,4 @@ features = ["js"]
 
 [features]
 # Support for generating default UUID, CUID, nanoid and datetime values.
-default_generators = ["uuid/v4", "cuid", "nanoid"]
+default_generators = ["uuid/v4", "uuid/v7", "cuid", "nanoid"]

query-engine/query-structure/src/default_value.rs

@@ -45,7 +45,7 @@ impl DefaultKind {
 
  /// Does this match @default(uuid(_))?
  pub fn is_uuid(&self) -> bool {
- matches!(self, DefaultKind::Expression(generator) if generator.name == "uuid")
+ matches!(self, DefaultKind::Expression(generator) if generator.name.starts_with("uuid"))
  }
 
  pub fn unwrap_single(self) -> PrismaValue {
@@ -186,8 +186,8 @@ impl ValueGenerator {
  ValueGenerator::new("cuid".to_owned(), vec![]).unwrap()
  }
 
- pub fn new_uuid() -> Self {
- ValueGenerator::new("uuid".to_owned(), vec![]).unwrap()
+ pub fn new_uuid(version: u8) -> Self {
+ ValueGenerator::new(format!("uuid({version})"), vec![]).unwrap()
  }
 
  pub fn new_nanoid(length: Option<u8>) -> Self {
@@ -238,7 +238,7 @@ impl ValueGenerator {
 
 #[derive(Clone, Copy, PartialEq)]
 pub enum ValueGeneratorFn {
- Uuid,
+ Uuid(u8),
  Cuid,
  Nanoid(Option<u8>),
  Now,
@@ -251,7 +251,8 @@ impl ValueGeneratorFn {
  fn new(name: &str) -> std::result::Result<Self, String> {
  match name {
  "cuid" => Ok(Self::Cuid),
- "uuid" => Ok(Self::Uuid),
+ "uuid" | "uuid(4)" => Ok(Self::Uuid(4)),
+ "uuid(7)" => Ok(Self::Uuid(7)),
  "now" => Ok(Self::Now),
  "autoincrement" => Ok(Self::Autoincrement),
  "sequence" => Ok(Self::Autoincrement),
@@ -265,7 +266,7 @@ impl ValueGeneratorFn {
  #[cfg(feature = "default_generators")]
  fn invoke(&self) -> Option<PrismaValue> {
  match self {
- Self::Uuid => Some(Self::generate_uuid()),
+ Self::Uuid(version) => Some(Self::generate_uuid(*version)),
  Self::Cuid => Some(Self::generate_cuid()),
  Self::Nanoid(length) => Some(Self::generate_nanoid(length)),
  Self::Now => Some(Self::generate_now()),
@@ -282,8 +283,12 @@ impl ValueGeneratorFn {
  }
 
  #[cfg(feature = "default_generators")]
- fn generate_uuid() -> PrismaValue {
- PrismaValue::Uuid(uuid::Uuid::new_v4())
+ fn generate_uuid(version: u8) -> PrismaValue {
+ PrismaValue::Uuid(match version {
+ 4 => uuid::Uuid::new_v4(),
+ 7 => uuid::Uuid::now_v7(),
+ _ => panic!("Unknown UUID version: {}", version),
+ })
  }
 
  #[cfg(feature = "default_generators")]
@@ -337,8 +342,16 @@ mod tests {
  }
 
  #[test]
- fn default_value_is_uuid() {
- let uuid_default = DefaultValue::new_expression(ValueGenerator::new_uuid());
+ fn default_value_is_uuidv4() {
+ let uuid_default = DefaultValue::new_expression(ValueGenerator::new_uuid(4));
+
+ assert!(uuid_default.is_uuid());
+ assert!(!uuid_default.is_autoincrement());
+ }
+
+ #[test]
+ fn default_value_is_uuidv7() {
+ let uuid_default = DefaultValue::new_expression(ValueGenerator::new_uuid(7));
 
  assert!(uuid_default.is_uuid());
  assert!(!uuid_default.is_autoincrement());

query-engine/query-structure/src/field/scalar.rs

@@ -244,8 +244,15 @@ pub fn dml_default_kind(default_value: &ast::Expression, scalar_type: Option<Sca
  ast::Expression::Function(funcname, _args, _) if funcname == "sequence" => {
  DefaultKind::Expression(ValueGenerator::new_sequence(Vec::new()))
  }
- ast::Expression::Function(funcname, _args, _) if funcname == "uuid" => {
- DefaultKind::Expression(ValueGenerator::new_uuid())
+ ast::Expression::Function(funcname, args, _) if funcname == "uuid" => {
+ let version = args
+ .arguments
+ .first()
+ .and_then(|arg| arg.value.as_numeric_value())
+ .map(|(val, _)| val.parse::<u8>().unwrap())
+ .unwrap_or(4);
+
+ DefaultKind::Expression(ValueGenerator::new_uuid(version))
  }
  ast::Expression::Function(funcname, _args, _) if funcname == "cuid" => {
  DefaultKind::Expression(ValueGenerator::new_cuid())