remove youid

Author: okkdev

README.md

@@ -5,6 +5,8 @@
 
 [TypeID (v0.3)](https://github.com/jetify-com/typeid) implementation in Gleam.
 
+Works on Erlang and Javascript.
+
 ## Installation
 
 ```sh
@@ -60,3 +62,5 @@ Further documentation can be found at <https://hexdocs.pm/typeid_gleam>.
 ```sh
 gleam test  # Run the tests
 ```
+
+Many thanks to lpil for the [youid](https://github.com/lpil/youid) UUID implementation

gleam.toml

@@ -9,11 +9,12 @@ repository = { type = "github", user = "okkdev", repo = "typeid_gleam" }
 # For a full reference of all the available options, you can have a look at
 # https://gleam.run/writing-gleam/gleam-toml/.
 
+internal_modules = ["typeid/uuid"]
+
 [dependencies]
 gleam_stdlib = ">= 0.44.0 and < 2.0.0"
 gleam_regexp = ">= 1.1.1 and < 2.0.0"
 gleam_time = ">= 1.2.0 and < 2.0.0"
-youid = ">= 1.5.1 and < 2.0.0"
 
 [dev-dependencies]
 gleeunit = ">= 1.0.0 and < 2.0.0"

manifest.toml

@@ -2,13 +2,11 @@
 # You typically do not need to edit this file
 
 packages = [
-  { name = "gleam_crypto", version = "1.5.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_crypto", source = "hex", outer_checksum = "50774BAFFF1144E7872814C566C5D653D83A3EBF23ACC3156B757A1B6819086E" },
   { name = "gleam_json", version = "3.0.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_json", source = "hex", outer_checksum = "5BA154440B22D9800955B1AB854282FA37B97F30F409D76B0824D0A60C934188" },
   { name = "gleam_regexp", version = "1.1.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_regexp", source = "hex", outer_checksum = "9C215C6CA84A5B35BB934A9B61A9A306EC743153BE2B0425A0D032E477B062A9" },
   { name = "gleam_stdlib", version = "0.60.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "621D600BB134BC239CB2537630899817B1A42E60A1D46C5E9F3FAE39F88C800B" },
   { name = "gleam_time", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_time", source = "hex", outer_checksum = "D71F1AFF7FEB534FF55E5DC58E534E9201BA75A444619788A2E4DEA4EBD87D16" },
   { name = "gleeunit", version = "1.5.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "D33B7736CF0766ED3065F64A1EBB351E72B2E8DE39BAFC8ADA0E35E92A6A934F" },
-  { name = "youid", version = "1.5.1", build_tools = ["gleam"], requirements = ["gleam_crypto", "gleam_stdlib", "gleam_time"], otp_app = "youid", source = "hex", outer_checksum = "580E909FD704DB16416D5CB080618EDC2DA0F1BE4D21B490C0683335E3FFC5AF" },
 ]
 
 [requirements]
@@ -17,4 +15,3 @@ gleam_regexp = { version = ">= 1.1.1 and < 2.0.0" }
 gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
 gleam_time = { version = ">= 1.2.0 and < 2.0.0" }
 gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
-youid = { version = ">= 1.5.1 and < 2.0.0" }

src/typeid.ffi.mjs

@@ -0,0 +1,7 @@
+import { BitArray } from "./gleam.mjs"
+
+export function strongRandomBytes(n) {
+  const array = new Uint8Array(n)
+  globalThis.crypto.getRandomValues(array)
+  return new BitArray(array)
+}

src/typeid.gleam

@@ -4,7 +4,7 @@ import gleam/list
 import gleam/regexp
 import gleam/result
 import gleam/string
-import youid/uuid
+import typeid/uuid
 
 const default_typeid = TypeId(prefix: "", suffix: "")
 
@@ -27,7 +27,7 @@ pub opaque type TypeId(a) {
 /// let assert Ok(id) = new("user")
 /// ```
 pub fn new(prefix prefix: String) -> Result(TypeId(a), String) {
-  from_uuid(prefix, uuid.v7_string())
+  from_uuid(prefix, uuid.v7())
 }
 
 /// Generate a TypeID using the supplied prefix and UUID.
@@ -46,9 +46,7 @@ pub fn from_uuid(
     True -> {
       case uuid.from_string(uuid) {
         Ok(uuid) -> {
-          let suffix =
-            uuid.to_bit_array(uuid)
-            |> encode_base32
+          let suffix = encode_base32(uuid)
 
           TypeId(prefix:, suffix:)
           |> Ok
@@ -123,9 +121,7 @@ pub fn decode(prefix kind: String) -> decode.Decoder(TypeId(a)) {
 /// ```
 pub fn uuid(typeid: TypeId(a)) -> String {
   let assert Ok(bits) = decode_base32(typeid.suffix)
-  let assert Ok(uuid) = uuid.from_bit_array(bits)
-
-  uuid.to_string(uuid)
+  uuid.to_string(bits)
 }
 
 /// Returns the prefix of the TypeId.

src/typeid/uuid.gleam

@@ -0,0 +1,83 @@
+import gleam/int
+import gleam/string
+import gleam/time/timestamp
+
+@external(erlang, "crypto", "strong_rand_bytes")
+@external(javascript, "../typeid.ffi.mjs", "strongRandomBytes")
+fn strong_random_bytes(a: Int) -> BitArray
+
+pub fn v7() -> String {
+  let #(sec, ns) =
+    timestamp.system_time()
+    |> timestamp.to_unix_seconds_and_nanoseconds()
+  let stamp = sec * 1000 + ns / 1_000_000
+  let assert <<a:size(12), b:size(62), _:size(6)>> = strong_random_bytes(10)
+  let value = <<stamp:48, 7:4, a:12, 2:2, b:62>>
+
+  to_string(value)
+}
+
+pub fn to_string(uuid: BitArray) -> String {
+  do_to_string(uuid, 0, "")
+}
+
+pub fn from_string(str: String) -> Result(BitArray, Nil) {
+  do_to_bit_array(str, 0, <<>>)
+}
+
+fn do_to_string(ints: BitArray, position: Int, acc: String) -> String {
+  case position {
+    8 | 13 | 18 | 23 -> do_to_string(ints, position + 1, acc <> "-")
+    _ ->
+      case ints {
+        <<i:size(4), rest:bits>> -> {
+          let string = int.to_base16(i) |> string.lowercase
+          do_to_string(rest, position + 1, acc <> string)
+        }
+        _ -> acc
+      }
+  }
+}
+
+fn do_to_bit_array(
+  str: String,
+  index: Int,
+  acc: BitArray,
+) -> Result(BitArray, Nil) {
+  case string.pop_grapheme(str) {
+    Error(Nil) if index == 32 -> Ok(acc)
+    Ok(#("-", rest)) if index < 32 -> do_to_bit_array(rest, index, acc)
+    Ok(#(c, rest)) if index < 32 ->
+      case hex_to_int(c) {
+        Ok(i) -> do_to_bit_array(rest, index + 1, <<acc:bits, i:size(4)>>)
+        Error(_) -> Error(Nil)
+      }
+    _ -> Error(Nil)
+  }
+}
+
+fn hex_to_int(c: String) -> Result(Int, Nil) {
+  let i = case c {
+    "0" -> 0
+    "1" -> 1
+    "2" -> 2
+    "3" -> 3
+    "4" -> 4
+    "5" -> 5
+    "6" -> 6
+    "7" -> 7
+    "8" -> 8
+    "9" -> 9
+    "a" | "A" -> 10
+    "b" | "B" -> 11
+    "c" | "C" -> 12
+    "d" | "D" -> 13
+    "e" | "E" -> 14
+    "f" | "F" -> 15
+    _ -> 16
+  }
+  case i {
+    16 -> Error(Nil)
+    x -> Ok(x)
+  }
+}

test/typeid_gleam_test.gleam

@@ -81,89 +81,98 @@ pub fn random_test() {
 // Valid tests
 
 pub fn nil_test() {
-  let assert Ok(id) =
-    typeid.from_uuid("", "00000000-0000-0000-0000-000000000000")
+  let uuid = "00000000-0000-0000-0000-000000000000"
+  let assert Ok(id) = typeid.from_uuid("", uuid)
   assert "" == typeid.prefix(id)
+  assert uuid == typeid.uuid(id)
   assert "00000000000000000000000000" == typeid.suffix(id)
   assert "00000000000000000000000000" == typeid.to_string(id)
 
   assert Ok(id) == typeid.parse("00000000000000000000000000")
 }
 
 pub fn one_test() {
-  let assert Ok(id) =
-    typeid.from_uuid("", "00000000-0000-0000-0000-000000000001")
+  let uuid = "00000000-0000-0000-0000-000000000001"
+  let assert Ok(id) = typeid.from_uuid("", uuid)
   assert "" == typeid.prefix(id)
+  assert uuid == typeid.uuid(id)
   assert "00000000000000000000000001" == typeid.suffix(id)
   assert "00000000000000000000000001" == typeid.to_string(id)
 
   assert Ok(id) == typeid.parse("00000000000000000000000001")
 }
 
 pub fn ten_test() {
-  let assert Ok(id) =
-    typeid.from_uuid("", "00000000-0000-0000-0000-00000000000a")
+  let uuid = "00000000-0000-0000-0000-00000000000a"
+  let assert Ok(id) = typeid.from_uuid("", uuid)
   assert "" == typeid.prefix(id)
+  assert uuid == typeid.uuid(id)
   assert "0000000000000000000000000a" == typeid.suffix(id)
   assert "0000000000000000000000000a" == typeid.to_string(id)
 
   assert Ok(id) == typeid.parse("0000000000000000000000000a")
 }
 
 pub fn sixteen_test() {
-  let assert Ok(id) =
-    typeid.from_uuid("", "00000000-0000-0000-0000-000000000010")
+  let uuid = "00000000-0000-0000-0000-000000000010"
+  let assert Ok(id) = typeid.from_uuid("", uuid)
   assert "" == typeid.prefix(id)
+  assert uuid == typeid.uuid(id)
   assert "0000000000000000000000000g" == typeid.suffix(id)
   assert "0000000000000000000000000g" == typeid.to_string(id)
 
   assert Ok(id) == typeid.parse("0000000000000000000000000g")
 }
 
 pub fn thirty_two_test() {
-  let assert Ok(id) =
-    typeid.from_uuid("", "00000000-0000-0000-0000-000000000020")
+  let uuid = "00000000-0000-0000-0000-000000000020"
+  let assert Ok(id) = typeid.from_uuid("", uuid)
   assert "" == typeid.prefix(id)
+  assert uuid == typeid.uuid(id)
   assert "00000000000000000000000010" == typeid.suffix(id)
   assert "00000000000000000000000010" == typeid.to_string(id)
 
   assert Ok(id) == typeid.parse("00000000000000000000000010")
 }
 
 pub fn max_valid_test() {
-  let assert Ok(id) =
-    typeid.from_uuid("", "ffffffff-ffff-ffff-ffff-ffffffffffff")
+  let uuid = "ffffffff-ffff-ffff-ffff-ffffffffffff"
+  let assert Ok(id) = typeid.from_uuid("", uuid)
   assert "" == typeid.prefix(id)
+  assert uuid == typeid.uuid(id)
   assert "7zzzzzzzzzzzzzzzzzzzzzzzzz" == typeid.suffix(id)
   assert "7zzzzzzzzzzzzzzzzzzzzzzzzz" == typeid.to_string(id)
 
   assert Ok(id) == typeid.parse("7zzzzzzzzzzzzzzzzzzzzzzzzz")
 }
 
 pub fn valid_alphabet_test() {
-  let assert Ok(id) =
-    typeid.from_uuid("prefix", "0110c853-1d09-52d8-d73e-1194e95b5f19")
+  let uuid = "0110c853-1d09-52d8-d73e-1194e95b5f19"
+  let assert Ok(id) = typeid.from_uuid("prefix", uuid)
   assert "prefix" == typeid.prefix(id)
+  assert uuid == typeid.uuid(id)
   assert "0123456789abcdefghjkmnpqrs" == typeid.suffix(id)
   assert "prefix_0123456789abcdefghjkmnpqrs" == typeid.to_string(id)
 
   assert Ok(id) == typeid.parse("prefix_0123456789abcdefghjkmnpqrs")
 }
 
 pub fn valid_uuidv7_test() {
-  let assert Ok(id) =
-    typeid.from_uuid("prefix", "01890a5d-ac96-774b-bcce-b302099a8057")
+  let uuid = "01890a5d-ac96-774b-bcce-b302099a8057"
+  let assert Ok(id) = typeid.from_uuid("prefix", uuid)
   assert "prefix" == typeid.prefix(id)
+  assert uuid == typeid.uuid(id)
   assert "01h455vb4pex5vsknk084sn02q" == typeid.suffix(id)
   assert "prefix_01h455vb4pex5vsknk084sn02q" == typeid.to_string(id)
 
   assert Ok(id) == typeid.parse("prefix_01h455vb4pex5vsknk084sn02q")
 }
 
 pub fn prefix_underscore_test() {
-  let assert Ok(id) =
-    typeid.from_uuid("pre_fix", "00000000-0000-0000-0000-000000000000")
+  let uuid = "00000000-0000-0000-0000-000000000000"
+  let assert Ok(id) = typeid.from_uuid("pre_fix", uuid)
   assert "pre_fix" == typeid.prefix(id)
+  assert uuid == typeid.uuid(id)
   assert "00000000000000000000000000" == typeid.suffix(id)
   assert "pre_fix_00000000000000000000000000" == typeid.to_string(id)