Version 4 rc1 (#6)

Changes in this version:
- **BREAKING CHANGE**: All `*byField`/`*ByField` functions are now `*byFields`/`*ByFields`, and take a `FieldMatch` case before the list of fields. The `Compat` namespace in both libraries will assist in this transition. In support of this change, the `Field` parameter name is optional; the library will generate parameter names for it if they are not specified.
- **BREAKING CHANGE**: The `Query` namespaces have had some significant work, particularly from the full-query perspective. Most have been broken up into the base query and modifiers `by*` that will combine the base query with the `WHERE` clause needed to satisfy the criteria.
- **FEATURE / BREAKING CHANGE**: PostgreSQL document fields will now be cast to numeric if the parameter value passed to the query is numeric. This drove the `Query` breaking changes, as the fields need to have their intended value for the library to generate the appropriate SQL. Additionally, if code assumes the library can be given something like `8` and transform it to `"8"`, this is no longer the case.
- **FEATURE**: All `Find` queries (except `byId`/`ById`) now have a version with the `Ordered` suffix. These take a list of fields by which the query should be ordered. A new `Field` method called `Named` can assist with creating these fields. Prefixing the field name with `n:` will cast the field to numeric in PostgreSQL (and will be ignored by SQLite); adding " DESC" to the field name will sort it descending (Z-A, high to low) instead of ascending (A-Z, low to high).
- **BREAKING CHANGE** (PostgreSQL only): `fieldNameParam`/`Parameters.FieldName` are now plural. The function still only generates one parameter, but the name is now the same between PostgreSQL and SQLite. The goal of this library is to abstract the differences away as much as practical, and this furthers that end. There are functions with these names in the `Compat` namespace.
- **FEATURE**: In the F# v3 library, lists of parameters were expected to be F#'s `List` type, and the C# version took either `List<T>` or `IEnumerable<T>`. In this version, these all expect `seq`/`IEnumerable<T>`. F#'s `List` satisfies the `seq` constraints, so this should not be a breaking change.
- **FEATURE**: `Field`s now may have qualifiers; this allows tables to be aliased when joining multiple tables (as all have the same `data` column). F# users can use `with` to specify this at creation, and both F# and C# can use the `WithQualifier` method to create a field with the qualifier specified. Parameter names for fields may be specified in a similar way, substituting `ParameterName` for `Qualifier`.

Reviewed-on: #6

src/Common/Library.fs

@@ -1,5 +1,7 @@
 namespace BitBadger.Documents
 
+open System.Security.Cryptography
+
 /// The types of logical operations available for JSON fields
 [<Struct>]
 type Op =
@@ -148,6 +150,70 @@ type ParameterName() =
             currentIdx <- currentIdx + 1
             $"@field{currentIdx}"
 
+#if NET6_0
+open System.Text
+#endif
+
+/// Automatically-generated document ID strategies
+[<Struct>]
+type AutoId =
+    /// No automatic IDs will be generated
+    | Disabled
+    /// Generate a MAX-plus-1 numeric value for documents
+    | Number
+    /// Generate a GUID for each document (as a lowercase, no-dashes, 32-character string)
+    | Guid
+    /// Generate a random string of hexadecimal characters for each document
+    | RandomString
+with
+    /// Generate a GUID string
+    static member GenerateGuid () =
+        System.Guid.NewGuid().ToString "N"
+    
+    /// Generate a string of random hexadecimal characters
+    static member GenerateRandomString (length: int) =
+#if NET8_0_OR_GREATER
+        RandomNumberGenerator.GetHexString(length, lowercase = true)
+#else
+        RandomNumberGenerator.GetBytes((length / 2) + 1)
+        |> Array.fold (fun (str: StringBuilder) byt -> str.Append(byt.ToString "x2")) (StringBuilder length)
+        |> function it -> it.Length <- length; it.ToString()
+#endif
+    
+    /// Does the given document need an automatic ID generated?
+    static member NeedsAutoId<'T> strategy (document: 'T) idProp =
+        match strategy with
+        | Disabled -> false
+        | _ ->
+            let prop = document.GetType().GetProperty idProp
+            if isNull prop then invalidOp $"{idProp} not found in document"
+            else
+                match strategy with
+                | Number ->
+                    if prop.PropertyType = typeof<int8> then
+                        let value = prop.GetValue document :?> int8
+                        value = int8 0
+                    elif prop.PropertyType = typeof<int16> then
+                        let value = prop.GetValue document :?> int16
+                        value = int16 0
+                    elif prop.PropertyType = typeof<int> then
+                        let value = prop.GetValue document :?> int
+                        value = 0
+                    elif prop.PropertyType = typeof<int64> then
+                        let value = prop.GetValue document :?> int64
+                        value = int64 0
+                    else invalidOp "Document ID was not a number; cannot auto-generate a Number ID"
+                | Guid | RandomString ->
+                    if prop.PropertyType = typeof<string> then
+                        let value =
+                            prop.GetValue document
+                            |> Option.ofObj
+                            |> Option.map (fun it -> it :?> string)
+                            |> Option.defaultValue ""
+                        value = ""
+                    else invalidOp "Document ID was not a string; cannot auto-generate GUID or random string"
+                | Disabled -> false
+
 
 /// The required document serialization implementation
 type IDocumentSerializer =
@@ -200,7 +266,7 @@ module Configuration =
         serializerValue
     
     /// The serialized name of the ID field for documents
-    let mutable idFieldValue = "Id"
+    let mutable private idFieldValue = "Id"
     
     /// Specify the name of the ID field for documents
     [<CompiledName "UseIdField">]
@@ -212,6 +278,32 @@ module Configuration =
     let idField () =
         idFieldValue
     
+    /// The automatic ID strategy used by the library
+    let mutable private autoIdValue = Disabled
+    
+    /// Specify the automatic ID generation strategy used by the library
+    [<CompiledName "UseAutoIdStrategy">]
+    let useAutoIdStrategy it =
+        autoIdValue <- it
+    
+    /// Retrieve the currently configured automatic ID generation strategy
+    [<CompiledName "AutoIdStrategy">]
+    let autoIdStrategy () =
+        autoIdValue
+    
+    /// The length of automatically generated random strings
+    let mutable private idStringLengthValue = 16
+    
+    /// Specify the length of automatically generated random strings
+    [<CompiledName "UseIdStringLength">]
+    let useIdStringLength length =
+        idStringLengthValue <- length
+    
+    /// Retrieve the currently configured length of automatically generated random strings
+    [<CompiledName "IdStringLength">]
+    let idStringLength () =
+        idStringLengthValue
+
 
 /// Query construction functions
 [<RequireQualifiedAccess>]

src/Directory.Build.props

@@ -6,6 +6,7 @@
     <AssemblyVersion>4.0.0.0</AssemblyVersion>
     <FileVersion>4.0.0.0</FileVersion>
     <VersionPrefix>4.0.0</VersionPrefix>
+    <VersionSuffix>rc1</VersionSuffix>
     <PackageReleaseNotes>Change ByField to ByFields; support dot-access to nested document fields; add Find*Ordered functions/methods; see project site for breaking changes and compatibility</PackageReleaseNotes>
     <Authors>danieljsummers</Authors>
     <Company>Bit Badger Solutions</Company>

src/Postgres/Library.fs

@@ -312,7 +312,23 @@ module WithProps =
         /// Insert a new document
         [<CompiledName "Insert">]
         let insert<'TDoc> tableName (document: 'TDoc) sqlProps =
-            Custom.nonQuery (Query.insert tableName) [ jsonParam "@data" document ] sqlProps
+            let query =
+                match Configuration.autoIdStrategy () with 
+                | Disabled -> Query.insert tableName
+                | strategy ->
+                    let idField   = Configuration.idField ()
+                    let dataParam =
+                        if AutoId.NeedsAutoId strategy document idField then
+                            match strategy with
+                            | Number ->
+                                $"' || (SELECT COALESCE(MAX((data->>'{idField}')::numeric), 0) + 1 FROM {tableName}) || '"
+                            | Guid -> $"\"{AutoId.GenerateGuid()}\""
+                            | RandomString -> $"\"{AutoId.GenerateRandomString(Configuration.idStringLength ())}\""
+                            | Disabled -> "@data"
+                            |> function it -> $"""@data::jsonb || ('{{"{idField}":{it}}}')::jsonb"""
+                        else "@data"
+                    (Query.insert tableName).Replace("@data", dataParam)
+            Custom.nonQuery query [ jsonParam "@data" document ] sqlProps
 
         /// Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
         [<CompiledName "Save">]

src/Sqlite/Extensions.fs

@@ -35,11 +35,11 @@ module Extensions =
         
         /// Insert a new document
         member conn.insert<'TDoc> tableName (document: 'TDoc) =
-            WithConn.insert<'TDoc> tableName document conn
+            WithConn.Document.insert<'TDoc> tableName document conn
 
         /// Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
         member conn.save<'TDoc> tableName (document: 'TDoc) =
-            WithConn.save tableName document conn
+            WithConn.Document.save tableName document conn
 
         /// Count all documents in a table
         member conn.countAll tableName =
@@ -159,12 +159,12 @@ type SqliteConnectionCSharpExtensions =
     /// Insert a new document
     [<Extension>]
     static member inline Insert<'TDoc>(conn, tableName, document: 'TDoc) =
-        WithConn.insert<'TDoc> tableName document conn
+        WithConn.Document.insert<'TDoc> tableName document conn
 
     /// Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
     [<Extension>]
     static member inline Save<'TDoc>(conn, tableName, document: 'TDoc) =
-        WithConn.save<'TDoc> tableName document conn
+        WithConn.Document.save<'TDoc> tableName document conn
 
     /// Count all documents in a table
     [<Extension>]

src/Sqlite/Library.fs

@@ -258,10 +258,29 @@ module WithConn =
         let ensureFieldIndex tableName indexName fields conn =
             Custom.nonQuery (Query.Definition.ensureIndexOn tableName indexName fields SQLite) [] conn
 
+    /// Commands to add documents
+    [<AutoOpen>]
+    module Document =
+        
         /// Insert a new document
         [<CompiledName "Insert">]
         let insert<'TDoc> tableName (document: 'TDoc) conn =
-        Custom.nonQuery (Query.insert tableName) [ jsonParam "@data" document ] conn
+            let query =
+                match Configuration.autoIdStrategy () with 
+                | Disabled -> Query.insert tableName
+                | strategy ->
+                    let idField   = Configuration.idField ()
+                    let dataParam =
+                        if AutoId.NeedsAutoId strategy document idField then
+                            match strategy with
+                            | Number -> $"(SELECT coalesce(max(data->>'{idField}'), 0) + 1 FROM {tableName})"
+                            | Guid -> $"'{AutoId.GenerateGuid()}'"
+                            | RandomString -> $"'{AutoId.GenerateRandomString(Configuration.idStringLength ())}'"
+                            | Disabled -> "@data"
+                            |> function it -> $"json_set(@data, '$.{idField}', {it})"
+                        else "@data"
+                    (Query.insert tableName).Replace("@data", dataParam)
+            Custom.nonQuery query [ jsonParam "@data" document ] conn
         
         /// Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
         [<CompiledName "Save">]
@@ -547,13 +566,13 @@ module Document =
     [<CompiledName "Insert">]
     let insert<'TDoc> tableName (document: 'TDoc) =
         use conn = Configuration.dbConn ()
-        WithConn.insert tableName document conn
+        WithConn.Document.insert tableName document conn
 
     /// Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
     [<CompiledName "Save">]
     let save<'TDoc> tableName (document: 'TDoc) =
         use conn = Configuration.dbConn ()
-        WithConn.save tableName document conn
+        WithConn.Document.save tableName document conn
 
 
 /// Commands to count documents

src/Tests.CSharp/CommonCSharpTests.cs

@@ -22,57 +22,9 @@ internal class TestSerializer : IDocumentSerializer
 public static class CommonCSharpTests
 {
     /// <summary>
-    /// Unit tests
+    /// Unit tests for the Op enum
     /// </summary>
-    [Tests]
+    private static readonly Test OpTests = TestList("Op",
-    public static readonly Test Unit = TestList("Common.C# Unit",
-    [
-        TestSequenced(
-            TestList("Configuration",
-            [
-                TestCase("UseSerializer succeeds", () =>
-                {
-                    try
-                    {
-                        Configuration.UseSerializer(new TestSerializer());
-
-                        var serialized = Configuration.Serializer().Serialize(new SubDocument
-                        {
-                            Foo = "howdy",
-                            Bar = "bye"
-                        });
-                        Expect.equal(serialized, "{\"Overridden\":true}", "Specified serializer was not used");
-
-                        var deserialized = Configuration.Serializer()
-                            .Deserialize<object>("{\"Something\":\"here\"}");
-                        Expect.isNull(deserialized, "Specified serializer should have returned null");
-                    }
-                    finally
-                    {
-                        Configuration.UseSerializer(DocumentSerializer.Default);
-                    }
-                }),
-                TestCase("Serializer returns configured serializer", () =>
-                {
-                    Expect.isTrue(ReferenceEquals(DocumentSerializer.Default, Configuration.Serializer()),
-                        "Serializer should have been the same");
-                }),
-                TestCase("UseIdField / IdField succeeds", () =>
-                {
-                    try
-                    {
-                        Expect.equal(Configuration.IdField(), "Id",
-                            "The default configured ID field was incorrect");
-                        Configuration.UseIdField("id");
-                        Expect.equal(Configuration.IdField(), "id", "UseIdField did not set the ID field");
-                    }
-                    finally
-                    {
-                        Configuration.UseIdField("Id");
-                    }
-                })
-            ])),
-        TestList("Op",
     [
         TestCase("EQ succeeds", () =>
         {
@@ -110,8 +62,12 @@ public static class CommonCSharpTests
         {
             Expect.equal(Op.NEX.ToString(), "IS NULL", "The \"not exists\" operator was not correct");
         })
-        ]),
+    ]);
-        TestList("Field",
+
+    /// <summary>
+    /// Unit tests for the Field class
+    /// </summary>
+    private static readonly Test FieldTests = TestList("Field",
     [
         TestCase("EQ succeeds", () =>
         {
@@ -245,8 +201,7 @@ public static class CommonCSharpTests
             TestCase("succeeds for a SQLite single field with a qualifier", () =>
             {
                 var field = Field.LT("SomethingElse", 9).WithQualifier("this");
-                    Expect.equal("this.data->>'SomethingElse'", field.Path(Dialect.SQLite),
+                Expect.equal("this.data->>'SomethingElse'", field.Path(Dialect.SQLite), "The SQLite path is incorrect");
-                        "The SQLite path is incorrect");
             }),
             TestCase("succeeds for a SQLite nested field with no qualifier", () =>
             {
@@ -257,12 +212,15 @@ public static class CommonCSharpTests
             TestCase("succeeds for a SQLite nested field with a qualifier", () =>
             {
                 var field = Field.EQ("Nest.Away", "doc").WithQualifier("bird");
-                    Expect.equal("bird.data->>'Nest'->>'Away'", field.Path(Dialect.SQLite),
+                Expect.equal("bird.data->>'Nest'->>'Away'", field.Path(Dialect.SQLite), "The SQLite path is incorrect");
-                        "The SQLite path is incorrect");
             })
         ])
-        ]),
+    ]);
-        TestList("FieldMatch.ToString",
+
+    /// <summary>
+    /// Unit tests for the FieldMatch enum
+    /// </summary>
+    private static readonly Test FieldMatchTests = TestList("FieldMatch.ToString",
     [
         TestCase("succeeds for Any", () =>
         {
@@ -272,8 +230,12 @@ public static class CommonCSharpTests
         {
             Expect.equal(FieldMatch.All.ToString(), "AND", "SQL for All is incorrect");
         })
-        ]),
+    ]);
-        TestList("ParameterName.Derive",
+
+    /// <summary>
+    /// Unit tests for the ParameterName class
+    /// </summary>
+    private static readonly Test ParameterNameTests = TestList("ParameterName.Derive",
     [
         TestCase("succeeds with existing name", () =>
         {
@@ -294,8 +256,229 @@ public static class CommonCSharpTests
             Expect.equal(name.Derive(FSharpOption<string>.None), "@field3",
                 "Counter should have advanced from previous call");
         })
-        ]),
+    ]);
-        TestList("Query",
+
+    /// <summary>
+    /// Unit tests for the AutoId enum
+    /// </summary>
+    private static readonly Test AutoIdTests = TestList("AutoId",
+    [
+        TestCase("GenerateGuid succeeds", () =>
+        {
+            var autoId = AutoId.GenerateGuid();
+            Expect.isNotNull(autoId, "The GUID auto-ID should not have been null");
+            Expect.stringHasLength(autoId, 32, "The GUID auto-ID should have been 32 characters long");
+            Expect.equal(autoId, autoId.ToLowerInvariant(), "The GUID auto-ID should have been lowercase");
+        }),
+        TestCase("GenerateRandomString succeeds", () =>
+        {
+            foreach (var length in (int[]) [6, 8, 12, 20, 32, 57, 64])
+            {
+                var autoId = AutoId.GenerateRandomString(length);
+                Expect.isNotNull(autoId, $"Random string ({length}) should not have been null");
+                Expect.stringHasLength(autoId, length, $"Random string should have been {length} characters long");
+                Expect.equal(autoId, autoId.ToLowerInvariant(),
+                    $"Random string ({length}) should have been lowercase");
+            }
+        }),
+        TestList("NeedsAutoId",
+        [
+            TestCase("succeeds when no auto ID is configured", () =>
+            {
+                Expect.isFalse(AutoId.NeedsAutoId(AutoId.Disabled, new object(), "id"),
+                    "Disabled auto-ID never needs an automatic ID");
+            }),
+            TestCase("fails for any when the ID property is not found", () =>
+            {
+                try
+                {
+                    _ = AutoId.NeedsAutoId(AutoId.Number, new { Key = "" }, "Id");
+                    Expect.isTrue(false, "Non-existent ID property should have thrown an exception");
+                }
+                catch (InvalidOperationException)
+                {
+                    // pass
+                }
+            }),
+            TestCase("succeeds for byte when the ID is zero", () =>
+            {
+                Expect.isTrue(AutoId.NeedsAutoId(AutoId.Number, new { Id = (sbyte)0 }, "Id"),
+                    "Zero ID should have returned true");
+            }),
+            TestCase("succeeds for byte when the ID is non-zero", () =>
+            {
+                Expect.isFalse(AutoId.NeedsAutoId(AutoId.Number, new { Id = (sbyte)4 }, "Id"),
+                    "Non-zero ID should have returned false");
+            }),
+            TestCase("succeeds for short when the ID is zero", () =>
+            {
+                Expect.isTrue(AutoId.NeedsAutoId(AutoId.Number, new { Id = (short)0 }, "Id"),
+                    "Zero ID should have returned true");
+            }),
+            TestCase("succeeds for short when the ID is non-zero", () =>
+            {
+                Expect.isFalse(AutoId.NeedsAutoId(AutoId.Number, new { Id = (short)7 }, "Id"),
+                    "Non-zero ID should have returned false");
+            }),
+            TestCase("succeeds for int when the ID is zero", () =>
+            {
+                Expect.isTrue(AutoId.NeedsAutoId(AutoId.Number, new { Id = 0 }, "Id"),
+                    "Zero ID should have returned true");
+            }),
+            TestCase("succeeds for int when the ID is non-zero", () =>
+            {
+                Expect.isFalse(AutoId.NeedsAutoId(AutoId.Number, new { Id = 32 }, "Id"),
+                    "Non-zero ID should have returned false");
+            }),
+            TestCase("succeeds for long when the ID is zero", () =>
+            {
+                Expect.isTrue(AutoId.NeedsAutoId(AutoId.Number, new { Id = 0L }, "Id"),
+                    "Zero ID should have returned true");
+            }),
+            TestCase("succeeds for long when the ID is non-zero", () =>
+            {
+                Expect.isFalse(AutoId.NeedsAutoId(AutoId.Number, new { Id = 80L }, "Id"),
+                    "Non-zero ID should have returned false");
+            }),
+            TestCase("fails for number when the ID is not a number", () =>
+            {
+                try
+                {
+                    _ = AutoId.NeedsAutoId(AutoId.Number, new { Id = "" }, "Id");
+                    Expect.isTrue(false, "Numeric ID against a string should have thrown an exception");
+                }
+                catch (InvalidOperationException)
+                {
+                    // pass
+                }
+            }),
+            TestCase("succeeds for GUID when the ID is blank", () =>
+            {
+                Expect.isTrue(AutoId.NeedsAutoId(AutoId.Guid, new { Id = "" }, "Id"),
+                    "Blank ID should have returned true");
+            }),
+            TestCase("succeeds for GUID when the ID is filled", () =>
+            {
+                Expect.isFalse(AutoId.NeedsAutoId(AutoId.Guid, new { Id = "abc" }, "Id"),
+                    "Filled ID should have returned false");
+            }),
+            TestCase("fails for GUID when the ID is not a string", () =>
+            {
+                try
+                {
+                    _ = AutoId.NeedsAutoId(AutoId.Guid, new { Id = 8 }, "Id");
+                    Expect.isTrue(false, "String ID against a number should have thrown an exception");
+                }
+                catch (InvalidOperationException)
+                {
+                    // pass
+                }
+            }),
+            TestCase("succeeds for RandomString when the ID is blank", () =>
+            {
+                Expect.isTrue(AutoId.NeedsAutoId(AutoId.RandomString, new { Id = "" }, "Id"),
+                    "Blank ID should have returned true");
+            }),
+            TestCase("succeeds for RandomString when the ID is filled", () =>
+            {
+                Expect.isFalse(AutoId.NeedsAutoId(AutoId.RandomString, new { Id = "x" }, "Id"),
+                    "Filled ID should have returned false");
+            }),
+            TestCase("fails for RandomString when the ID is not a string", () =>
+            {
+                try
+                {
+                    _ = AutoId.NeedsAutoId(AutoId.RandomString, new { Id = 33 }, "Id");
+                    Expect.isTrue(false, "String ID against a number should have thrown an exception");
+                }
+                catch (InvalidOperationException)
+                {
+                    // pass
+                }
+            })
+        ])
+    ]);
+    
+    /// <summary>
+    /// Unit tests for the Configuration static class
+    /// </summary>
+    private static readonly Test ConfigurationTests = TestList("Configuration",
+    [
+        TestCase("UseSerializer succeeds", () =>
+        {
+            try
+            {
+                Configuration.UseSerializer(new TestSerializer());
+
+                var serialized = Configuration.Serializer().Serialize(new SubDocument
+                {
+                    Foo = "howdy",
+                    Bar = "bye"
+                });
+                Expect.equal(serialized, "{\"Overridden\":true}", "Specified serializer was not used");
+
+                var deserialized = Configuration.Serializer()
+                    .Deserialize<object>("{\"Something\":\"here\"}");
+                Expect.isNull(deserialized, "Specified serializer should have returned null");
+            }
+            finally
+            {
+                Configuration.UseSerializer(DocumentSerializer.Default);
+            }
+        }),
+        TestCase("Serializer returns configured serializer", () =>
+        {
+            Expect.isTrue(ReferenceEquals(DocumentSerializer.Default, Configuration.Serializer()),
+                "Serializer should have been the same");
+        }),
+        TestCase("UseIdField / IdField succeeds", () =>
+        {
+            try
+            {
+                Expect.equal(Configuration.IdField(), "Id",
+                    "The default configured ID field was incorrect");
+                Configuration.UseIdField("id");
+                Expect.equal(Configuration.IdField(), "id", "UseIdField did not set the ID field");
+            }
+            finally
+            {
+                Configuration.UseIdField("Id");
+            }
+        }),
+        TestCase("UseAutoIdStrategy / AutoIdStrategy succeeds", () =>
+        {
+            try
+            {
+                Expect.equal(Configuration.AutoIdStrategy(), AutoId.Disabled,
+                    "The default auto-ID strategy was incorrect");
+                Configuration.UseAutoIdStrategy(AutoId.Guid);
+                Expect.equal(Configuration.AutoIdStrategy(), AutoId.Guid,
+                    "The auto-ID strategy was not set correctly");
+            }
+            finally
+            {
+                Configuration.UseAutoIdStrategy(AutoId.Disabled);
+            }
+        }),
+        TestCase("UseIdStringLength / IdStringLength succeeds", () =>
+        {
+            try
+            {
+                Expect.equal(Configuration.IdStringLength(), 16, "The default ID string length was incorrect");
+                Configuration.UseIdStringLength(33);
+                Expect.equal(Configuration.IdStringLength(), 33, "The ID string length was not set correctly");
+            }
+            finally
+            {
+                Configuration.UseIdStringLength(16);
+            }
+        })
+    ]);
+
+    /// <summary>
+    /// Unit tests for the Query static class
+    /// </summary>
+    private static readonly Test QueryTests = TestList("Query",
     [
         TestCase("StatementWhere succeeds", () =>
         {
@@ -386,8 +569,7 @@ public static class CommonCSharpTests
         [
             TestCase("succeeds for no fields", () =>
             {
-                    Expect.equal(Query.OrderBy([], Dialect.PostgreSQL), "",
+                Expect.equal(Query.OrderBy([], Dialect.PostgreSQL), "", "Order By should have been blank (PostgreSQL)");
-                        "Order By should have been blank (PostgreSQL)");
                 Expect.equal(Query.OrderBy([], Dialect.SQLite), "", "Order By should have been blank (SQLite)");
             }),
             TestCase("succeeds for PostgreSQL with one field and no direction", () =>
@@ -407,8 +589,7 @@ public static class CommonCSharpTests
                         [
                             Field.Named("Nested.Test.Field DESC"), Field.Named("AnotherField"),
                             Field.Named("It DESC")
-                            ],
+                        ], Dialect.PostgreSQL),
-                            Dialect.PostgreSQL),
                     " ORDER BY data#>>'{Nested,Test,Field}' DESC, data->>'AnotherField', data->>'It' DESC",
                     "Order By not constructed correctly");
             }),
@@ -419,8 +600,7 @@ public static class CommonCSharpTests
                         [
                             Field.Named("Nested.Test.Field DESC"), Field.Named("AnotherField"),
                             Field.Named("It DESC")
-                            ],
+                        ], Dialect.SQLite),
-                            Dialect.SQLite),
                     " ORDER BY data->>'Nested'->>'Test'->>'Field' DESC, data->>'AnotherField', data->>'It' DESC",
                     "Order By not constructed correctly");
             }),
@@ -435,6 +615,20 @@ public static class CommonCSharpTests
                     "Order By not constructed correctly for numeric field");
             })
         ])
-        ])
+    ]);
+    
+    /// <summary>
+    /// Unit tests
+    /// </summary>
+    [Tests]
+    public static readonly Test Unit = TestList("Common.C# Unit",
+    [
+        OpTests,
+        FieldTests,
+        FieldMatchTests,
+        ParameterNameTests,
+        AutoIdTests,
+        QueryTests,
+        TestSequenced(ConfigurationTests)
     ]);
 }

src/Tests.CSharp/PostgresCSharpTests.cs

@@ -170,7 +170,11 @@ public static class PostgresCSharpTests
                     Expect.isTrue(false, "The parameter was not a StringArray type");
                 }
             })
-        ])
+        ]),
+        TestCase("None succeeds", () =>
+        {
+            Expect.isEmpty(Parameters.None, "The no-params sequence should be empty");
+        })
     ]);
 
     /// <summary>
@@ -310,15 +314,6 @@ public static class PostgresCSharpTests
         })
     ]);
     
-    /// <summary>
-    /// Tests which do not hit the database
-    /// </summary>
-    private static readonly Test Unit = TestList("Unit",
-    [
-        ParametersTests,
-        QueryTests
-    ]);
-
     private static readonly List<JsonDocument> TestDocuments =
     [
         new() { Id = "one", Value = "FIRST!", NumValue = 0 },
@@ -548,6 +543,83 @@ public static class PostgresCSharpTests
                 {
                     // This is what should have happened
                 }
+            }),
+            TestCase("succeeds when adding a numeric auto ID", async () =>
+            {
+                try
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.Number);
+                    Configuration.UseIdField("Key");
+                    await using var db = PostgresDb.BuildDb();
+                    var before = await Count.All(PostgresDb.TableName);
+                    Expect.equal(before, 0, "There should be no documents in the table");
+
+                    await Document.Insert(PostgresDb.TableName, new NumIdDocument { Text = "one" });
+                    await Document.Insert(PostgresDb.TableName, new NumIdDocument { Text = "two" });
+                    await Document.Insert(PostgresDb.TableName, new NumIdDocument { Key = 77, Text = "three" });
+                    await Document.Insert(PostgresDb.TableName, new NumIdDocument { Text = "four" });
+
+                    var after = await Find.AllOrdered<NumIdDocument>(PostgresDb.TableName, [Field.Named("n:Key")]);
+                    Expect.hasLength(after, 4, "There should have been 4 documents returned");
+                    Expect.sequenceEqual(after.Select(x => x.Key), [1, 2, 77, 78],
+                        "The IDs were not generated correctly");
+                }
+                finally
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.Disabled);
+                    Configuration.UseIdField("Id");
+                }
+            }),
+            TestCase("succeeds when adding a GUID auto ID", async () =>
+            {
+                try
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.Guid);
+                    await using var db = PostgresDb.BuildDb();
+                    var before = await Count.All(PostgresDb.TableName);
+                    Expect.equal(before, 0, "There should be no documents in the table");
+
+                    await Document.Insert(PostgresDb.TableName, new JsonDocument { Value = "one" });
+                    await Document.Insert(PostgresDb.TableName, new JsonDocument { Value = "two" });
+                    await Document.Insert(PostgresDb.TableName, new JsonDocument { Id = "abc123", Value = "three" });
+                    await Document.Insert(PostgresDb.TableName, new JsonDocument { Value = "four" });
+
+                    var after = await Find.All<JsonDocument>(PostgresDb.TableName);
+                    Expect.hasLength(after, 4, "There should have been 4 documents returned");
+                    Expect.equal(after.Count(x => x.Id.Length == 32), 3, "Three of the IDs should have been GUIDs");
+                    Expect.equal(after.Count(x => x.Id == "abc123"), 1, "The provided ID should have been used as-is");
+                }
+                finally
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.Disabled);
+                }
+            }),
+            TestCase("succeeds when adding a RandomString auto ID", async () =>
+            {
+                try
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.RandomString);
+                    Configuration.UseIdStringLength(44);
+                    await using var db = PostgresDb.BuildDb();
+                    var before = await Count.All(PostgresDb.TableName);
+                    Expect.equal(before, 0, "There should be no documents in the table");
+
+                    await Document.Insert(PostgresDb.TableName, new JsonDocument { Value = "one" });
+                    await Document.Insert(PostgresDb.TableName, new JsonDocument { Value = "two" });
+                    await Document.Insert(PostgresDb.TableName, new JsonDocument { Id = "abc123", Value = "three" });
+                    await Document.Insert(PostgresDb.TableName, new JsonDocument { Value = "four" });
+
+                    var after = await Find.All<JsonDocument>(PostgresDb.TableName);
+                    Expect.hasLength(after, 4, "There should have been 4 documents returned");
+                    Expect.equal(after.Count(x => x.Id.Length == 44), 3,
+                        "Three of the IDs should have been 44-character random strings");
+                    Expect.equal(after.Count(x => x.Id == "abc123"), 1, "The provided ID should have been used as-is");
+                }
+                finally
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.Disabled);
+                    Configuration.UseIdStringLength(16);
+                }
             })
         ]),
         TestList("Save",

src/Tests.CSharp/SqliteCSharpTests.cs

@@ -325,9 +325,86 @@ public static class SqliteCSharpTests
                 {
                     // This is what is supposed to happen
                 }
+            }),
+            TestCase("succeeds when adding a numeric auto ID", async () =>
+            {
+                try
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.Number);
+                    Configuration.UseIdField("Key");
+                    await using var db = await SqliteDb.BuildDb();
+                    var before = await Count.All(SqliteDb.TableName);
+                    Expect.equal(before, 0L, "There should be no documents in the table");
+
+                    await Document.Insert(SqliteDb.TableName, new NumIdDocument { Text = "one" });
+                    await Document.Insert(SqliteDb.TableName, new NumIdDocument { Text = "two" });
+                    await Document.Insert(SqliteDb.TableName, new NumIdDocument { Key = 77, Text = "three" });
+                    await Document.Insert(SqliteDb.TableName, new NumIdDocument { Text = "four" });
+
+                    var after = await Find.AllOrdered<NumIdDocument>(SqliteDb.TableName, [Field.Named("Key")]);
+                    Expect.hasLength(after, 4, "There should have been 4 documents returned");
+                    Expect.sequenceEqual(after.Select(x => x.Key), [1, 2, 77, 78],
+                        "The IDs were not generated correctly");
+                }
+                finally
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.Disabled);
+                    Configuration.UseIdField("Id");
+                }
+            }),
+            TestCase("succeeds when adding a GUID auto ID", async () =>
+            {
+                try
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.Guid);
+                    await using var db = await SqliteDb.BuildDb();
+                    var before = await Count.All(SqliteDb.TableName);
+                    Expect.equal(before, 0L, "There should be no documents in the table");
+
+                    await Document.Insert(SqliteDb.TableName, new JsonDocument { Value = "one" });
+                    await Document.Insert(SqliteDb.TableName, new JsonDocument { Value = "two" });
+                    await Document.Insert(SqliteDb.TableName, new JsonDocument { Id = "abc123", Value = "three" });
+                    await Document.Insert(SqliteDb.TableName, new JsonDocument { Value = "four" });
+
+                    var after = await Find.All<JsonDocument>(SqliteDb.TableName);
+                    Expect.hasLength(after, 4, "There should have been 4 documents returned");
+                    Expect.equal(after.Count(x => x.Id.Length == 32), 3, "Three of the IDs should have been GUIDs");
+                    Expect.equal(after.Count(x => x.Id == "abc123"), 1, "The provided ID should have been used as-is");
+                }
+                finally
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.Disabled);
+                }
+            }),
+            TestCase("succeeds when adding a RandomString auto ID", async () =>
+            {
+                try
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.RandomString);
+                    Configuration.UseIdStringLength(44);
+                    await using var db = await SqliteDb.BuildDb();
+                    var before = await Count.All(SqliteDb.TableName);
+                    Expect.equal(before, 0L, "There should be no documents in the table");
+
+                    await Document.Insert(SqliteDb.TableName, new JsonDocument { Value = "one" });
+                    await Document.Insert(SqliteDb.TableName, new JsonDocument { Value = "two" });
+                    await Document.Insert(SqliteDb.TableName, new JsonDocument { Id = "abc123", Value = "three" });
+                    await Document.Insert(SqliteDb.TableName, new JsonDocument { Value = "four" });
+
+                    var after = await Find.All<JsonDocument>(SqliteDb.TableName);
+                    Expect.hasLength(after, 4, "There should have been 4 documents returned");
+                    Expect.equal(after.Count(x => x.Id.Length == 44), 3,
+                        "Three of the IDs should have been 44-character random strings");
+                    Expect.equal(after.Count(x => x.Id == "abc123"), 1, "The provided ID should have been used as-is");
+                }
+                finally
+                {
+                    Configuration.UseAutoIdStrategy(AutoId.Disabled);
+                    Configuration.UseIdStringLength(16);
+                }
             })
         ]),
-        TestList("Document.Save",
+        TestList("Save",
         [
             TestCase("succeeds when a document is inserted", async () =>
             {

src/Tests.CSharp/Types.cs

@@ -1,5 +1,11 @@
 namespace BitBadger.Documents.Tests.CSharp;
 
+public class NumIdDocument
+{
+    public int Key { get; set; } = 0;
+    public string Text { get; set; } = "";
+}
+
 public class SubDocument
 {
     public string Foo { get; set; } = "";

src/Tests/BitBadger.Documents.Tests.fsproj

@@ -6,8 +6,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <Compile Include="CommonTests.fs" />
     <Compile Include="Types.fs" />
+    <Compile Include="CommonTests.fs" />
     <Compile Include="PostgresTests.fs" />
     <Compile Include="PostgresExtensionTests.fs" />
     <Compile Include="SqliteTests.fs" />

src/Tests/CommonTests.fs

@@ -6,10 +6,8 @@ open Expecto
 /// Test table name
 let tbl = "test_table"
 
-/// Tests which do not hit the database
+/// Unit tests for the Op DU
-let all =
+let opTests = testList "Op" [
-    testList "Common" [
-        testList "Op" [
     test "EQ succeeds" {
         Expect.equal (string EQ) "=" "The equals operator was not correct"
     }
@@ -38,7 +36,9 @@ let all =
         Expect.equal (string NEX) "IS NULL" """The "not exists" operator was not correct"""
     }
 ]
-        testList "Field" [
+
+/// Unit tests for the Field class
+let fieldTests = testList "Field" [
     test "EQ succeeds" {
         let field = Field.EQ "Test" 14
         Expect.equal field.Name "Test" "Field name incorrect"
@@ -111,12 +111,10 @@ let all =
     }
     testList "NameToPath" [
         test "succeeds for PostgreSQL and a simple name" {
-                    Expect.equal
+            Expect.equal "data->>'Simple'" (Field.NameToPath "Simple" PostgreSQL) "Path not constructed correctly"
-                        "data->>'Simple'" (Field.NameToPath "Simple" PostgreSQL) "Path not constructed correctly"
         }
         test "succeeds for SQLite and a simple name" {
-                    Expect.equal
+            Expect.equal "data->>'Simple'" (Field.NameToPath "Simple" SQLite) "Path not constructed correctly"
-                        "data->>'Simple'" (Field.NameToPath "Simple" SQLite) "Path not constructed correctly"
         }
         test "succeeds for PostgreSQL and a nested name" {
             Expect.equal
@@ -148,8 +146,7 @@ let all =
         }
         test "succeeds for a PostgreSQL single field with a qualifier" {
             let field = { Field.LT "SomethingElse" 9 with Qualifier = Some "this" }
-                    Expect.equal
+            Expect.equal "this.data->>'SomethingElse'" (field.Path PostgreSQL) "The PostgreSQL path is incorrect"
-                        "this.data->>'SomethingElse'" (field.Path PostgreSQL) "The PostgreSQL path is incorrect"
         }
         test "succeeds for a PostgreSQL nested field with no qualifier" {
             let field = Field.EQ "My.Nested.Field" "howdy"
@@ -177,7 +174,9 @@ let all =
         }
     ]
 ]
-        testList "FieldMatch.ToString" [
+
+/// Unit tests for the FieldMatch DU
+let fieldMatchTests = testList "FieldMatch.ToString" [
     test "succeeds for Any" {
         Expect.equal (string Any) "OR" "SQL for Any is incorrect"
     }
@@ -185,7 +184,9 @@ let all =
         Expect.equal (string All) "AND" "SQL for All is incorrect"
     }
 ]
-        testList "ParameterName.Derive" [
+
+/// Unit tests for the ParameterName class
+let parameterNameTests = testList "ParameterName.Derive" [
     test "succeeds with existing name" {
         let name = ParameterName()
         Expect.equal (name.Derive(Some "@taco")) "@taco" "Name should have been @taco"
@@ -199,7 +200,136 @@ let all =
         Expect.equal (name.Derive None) "@field3" "Counter should have advanced from previous call"
     }
 ]
-        testList "Query" [
+
+/// Unit tests for the AutoId DU
+let autoIdTests = testList "AutoId" [
+    test "GenerateGuid succeeds" {
+        let autoId = AutoId.GenerateGuid()
+        Expect.isNotNull autoId "The GUID auto-ID should not have been null"
+        Expect.stringHasLength autoId 32 "The GUID auto-ID should have been 32 characters long"
+        Expect.equal autoId (autoId.ToLowerInvariant ()) "The GUID auto-ID should have been lowercase"
+    }
+    test "GenerateRandomString succeeds" {
+        [ 6; 8; 12; 20; 32; 57; 64 ]
+        |> List.iter (fun length ->
+            let autoId = AutoId.GenerateRandomString length
+            Expect.isNotNull autoId $"Random string ({length}) should not have been null"
+            Expect.stringHasLength autoId length $"Random string should have been {length} characters long"
+            Expect.equal autoId (autoId.ToLowerInvariant ()) $"Random string ({length}) should have been lowercase")
+    }
+    testList "NeedsAutoId" [
+        test "succeeds when no auto ID is configured" {
+            Expect.isFalse (AutoId.NeedsAutoId Disabled (obj ()) "id") "Disabled auto-ID never needs an automatic ID"
+        }
+        test "fails for any when the ID property is not found" {
+            Expect.throwsT<System.InvalidOperationException>
+                (fun () -> AutoId.NeedsAutoId Number {| Key = "" |} "Id" |> ignore)
+                "Non-existent ID property should have thrown an exception"
+        }
+        test "succeeds for byte when the ID is zero" {
+            Expect.isTrue (AutoId.NeedsAutoId Number {| Id = int8 0 |} "Id") "Zero ID should have returned true"
+        }
+        test "succeeds for byte when the ID is non-zero" {
+            Expect.isFalse (AutoId.NeedsAutoId Number {| Id = int8 4 |} "Id") "Non-zero ID should have returned false"
+        }
+        test "succeeds for short when the ID is zero" {
+            Expect.isTrue (AutoId.NeedsAutoId Number {| Id = int16 0 |} "Id") "Zero ID should have returned true"
+        }
+        test "succeeds for short when the ID is non-zero" {
+            Expect.isFalse (AutoId.NeedsAutoId Number {| Id = int16 7 |} "Id") "Non-zero ID should have returned false"
+        }
+        test "succeeds for int when the ID is zero" {
+            Expect.isTrue (AutoId.NeedsAutoId Number {| Id = 0 |} "Id") "Zero ID should have returned true"
+        }
+        test "succeeds for int when the ID is non-zero" {
+            Expect.isFalse (AutoId.NeedsAutoId Number {| Id = 32 |} "Id") "Non-zero ID should have returned false"
+        }
+        test "succeeds for long when the ID is zero" {
+            Expect.isTrue (AutoId.NeedsAutoId Number {| Id = 0L |} "Id") "Zero ID should have returned true"
+        }
+        test "succeeds for long when the ID is non-zero" {
+            Expect.isFalse (AutoId.NeedsAutoId Number {| Id = 80L |} "Id") "Non-zero ID should have returned false"
+        }
+        test "fails for number when the ID is not a number" {
+            Expect.throwsT<System.InvalidOperationException>
+                (fun () -> AutoId.NeedsAutoId Number {| Id = "" |} "Id" |> ignore)
+                "Numeric ID against a string should have thrown an exception"
+        }
+        test "succeeds for GUID when the ID is blank" {
+            Expect.isTrue (AutoId.NeedsAutoId Guid {| Id = "" |} "Id") "Blank ID should have returned true"
+        }
+        test "succeeds for GUID when the ID is filled" {
+            Expect.isFalse (AutoId.NeedsAutoId Guid {| Id = "abc" |} "Id") "Filled ID should have returned false"
+        }
+        test "fails for GUID when the ID is not a string" {
+            Expect.throwsT<System.InvalidOperationException>
+                (fun () -> AutoId.NeedsAutoId Guid {| Id = 8 |} "Id" |> ignore)
+                "String ID against a number should have thrown an exception"
+        }
+        test "succeeds for RandomString when the ID is blank" {
+            Expect.isTrue (AutoId.NeedsAutoId RandomString {| Id = "" |} "Id") "Blank ID should have returned true"
+        }
+        test "succeeds for RandomString when the ID is filled" {
+            Expect.isFalse (AutoId.NeedsAutoId RandomString {| Id = "x" |} "Id") "Filled ID should have returned false"
+        }
+        test "fails for RandomString when the ID is not a string" {
+            Expect.throwsT<System.InvalidOperationException>
+                (fun () -> AutoId.NeedsAutoId RandomString {| Id = 33 |} "Id" |> ignore)
+                "String ID against a number should have thrown an exception"
+        }
+    ]
+]
+
+/// Unit tests for the Configuration module
+let configurationTests = testList "Configuration" [
+    test "useSerializer succeeds" {
+        try
+            Configuration.useSerializer
+                { new IDocumentSerializer with
+                    member _.Serialize<'T>(it: 'T) : string = """{"Overridden":true}"""
+                    member _.Deserialize<'T>(it: string) : 'T = Unchecked.defaultof<'T>
+                }
+            
+            let serialized = Configuration.serializer().Serialize {| Foo = "howdy"; Bar = "bye" |}
+            Expect.equal serialized """{"Overridden":true}""" "Specified serializer was not used"
+            
+            let deserialized = Configuration.serializer().Deserialize<obj> """{"Something":"here"}"""
+            Expect.isNull deserialized "Specified serializer should have returned null"
+        finally
+            Configuration.useSerializer DocumentSerializer.``default``
+    }
+    test "serializer returns configured serializer" {
+        Expect.isTrue (obj.ReferenceEquals(DocumentSerializer.``default``, Configuration.serializer ()))
+            "Serializer should have been the same"
+    }
+    test "useIdField / idField succeeds" {
+        try
+            Expect.equal (Configuration.idField ()) "Id" "The default configured ID field was incorrect"
+            Configuration.useIdField "id"
+            Expect.equal (Configuration.idField ()) "id" "useIdField did not set the ID field"
+        finally
+            Configuration.useIdField "Id"
+    }
+    test "useAutoIdStrategy / autoIdStrategy succeeds" {
+        try
+            Expect.equal (Configuration.autoIdStrategy ()) Disabled "The default auto-ID strategy was incorrect"
+            Configuration.useAutoIdStrategy Guid
+            Expect.equal (Configuration.autoIdStrategy ()) Guid "The auto-ID strategy was not set correctly"
+        finally
+            Configuration.useAutoIdStrategy Disabled
+    }
+    test "useIdStringLength / idStringLength succeeds" {
+        try
+            Expect.equal (Configuration.idStringLength ()) 16 "The default ID string length was incorrect"
+            Configuration.useIdStringLength 33
+            Expect.equal (Configuration.idStringLength ()) 33 "The ID string length was not set correctly"
+        finally
+            Configuration.useIdStringLength 16
+    }
+]
+
+/// Unit tests for the Query module
+let queryTests = testList "Query" [
     test "statementWhere succeeds" {
         Expect.equal (Query.statementWhere "x" "y") "x WHERE y" "Statements not combined correctly"
     }
@@ -322,4 +452,14 @@ let all =
         }
     ]
 ]
+
+/// Tests which do not hit the database
+let all = testList "Common" [
+    opTests
+    fieldTests
+    fieldMatchTests
+    parameterNameTests
+    autoIdTests
+    queryTests
+    testSequenced configurationTests
 ]

src/Tests/PostgresTests.fs

@@ -252,18 +252,9 @@ let queryTests = testList "Query" [
 open ThrowawayDb.Postgres
 open Types
 
-/// Documents to use for integration tests
-let documents = [
-    { Id = "one"; Value = "FIRST!"; NumValue = 0; Sub = None }
-    { Id = "two"; Value = "another"; NumValue = 10; Sub = Some { Foo = "green"; Bar = "blue" } }
-    { Id = "three"; Value = ""; NumValue = 4; Sub = None }
-    { Id = "four"; Value = "purple"; NumValue = 17; Sub = Some { Foo = "green"; Bar = "red" } }
-    { Id = "five"; Value = "purple"; NumValue = 18; Sub = None }
-]
-
 /// Load the test documents into the database
 let loadDocs () = backgroundTask {
-    for doc in documents do do! insert PostgresDb.TableName doc
+    for doc in testDocuments do do! insert PostgresDb.TableName doc
 }
 
 /// Integration tests for the Configuration module of the PostgreSQL library
@@ -435,6 +426,68 @@ let documentTests = testList "Document" [
                     |> Async.RunSynchronously)
                 "An exception should have been raised for duplicate document ID insert"
         }
+        testTask "succeeds when adding a numeric auto ID" {
+            try
+                Configuration.useAutoIdStrategy Number
+                Configuration.useIdField "Key"
+                use db = PostgresDb.BuildDb()
+                let! before = Count.all PostgresDb.TableName
+                Expect.equal before 0 "There should be no documents in the table"
+                
+                do! insert PostgresDb.TableName { Key = 0; Text = "one" }
+                do! insert PostgresDb.TableName { Key = 0; Text = "two" }
+                do! insert PostgresDb.TableName { Key = 77; Text = "three" }
+                do! insert PostgresDb.TableName { Key = 0; Text = "four" }
+                
+                let! after = Find.allOrdered<NumIdDocument> PostgresDb.TableName [ Field.Named "n:Key" ]
+                Expect.hasLength after 4 "There should have been 4 documents returned"
+                Expect.equal (after |> List.map _.Key) [ 1; 2; 77; 78 ] "The IDs were not generated correctly"
+            finally
+                Configuration.useAutoIdStrategy Disabled
+                Configuration.useIdField "Id"
+        }
+        testTask "succeeds when adding a GUID auto ID" {
+            try
+                Configuration.useAutoIdStrategy Guid
+                use db = PostgresDb.BuildDb()
+                let! before = Count.all PostgresDb.TableName
+                Expect.equal before 0 "There should be no documents in the table"
+                
+                do! insert PostgresDb.TableName { emptyDoc with Value = "one" }
+                do! insert PostgresDb.TableName { emptyDoc with Value = "two" }
+                do! insert PostgresDb.TableName { emptyDoc with Id = "abc123"; Value = "three" }
+                do! insert PostgresDb.TableName { emptyDoc with Value = "four" }
+                
+                let! after = Find.all<JsonDocument> PostgresDb.TableName
+                Expect.hasLength after 4 "There should have been 4 documents returned"
+                Expect.hasCountOf after 3u (fun doc -> doc.Id.Length = 32) "Three of the IDs should have been GUIDs"
+                Expect.hasCountOf after 1u (fun doc -> doc.Id = "abc123") "The provided ID should have been used as-is"
+            finally
+                Configuration.useAutoIdStrategy Disabled
+        }
+        testTask "succeeds when adding a RandomString auto ID" {
+            try
+                Configuration.useAutoIdStrategy RandomString
+                Configuration.useIdStringLength 44
+                use db = PostgresDb.BuildDb()
+                let! before = Count.all PostgresDb.TableName
+                Expect.equal before 0 "There should be no documents in the table"
+                
+                do! insert PostgresDb.TableName { emptyDoc with Value = "one" }
+                do! insert PostgresDb.TableName { emptyDoc with Value = "two" }
+                do! insert PostgresDb.TableName { emptyDoc with Id = "abc123"; Value = "three" }
+                do! insert PostgresDb.TableName { emptyDoc with Value = "four" }
+                
+                let! after = Find.all<JsonDocument> PostgresDb.TableName
+                Expect.hasLength after 4 "There should have been 4 documents returned"
+                Expect.hasCountOf
+                    after 3u (fun doc -> doc.Id.Length = 44)
+                    "Three of the IDs should have been 44-character random strings"
+                Expect.hasCountOf after 1u (fun doc -> doc.Id = "abc123") "The provided ID should have been used as-is"
+            finally
+                Configuration.useAutoIdStrategy Disabled
+                Configuration.useIdStringLength 16
+        }
     ]
     testList "save" [
         testTask "succeeds when a document is inserted" {

src/Tests/SqliteTests.fs

@@ -118,18 +118,9 @@ let parametersTests = testList "Parameters" [
 
 (** INTEGRATION TESTS **)
 
-/// Documents used for integration tests
-let documents = [
-    { Id = "one"; Value = "FIRST!"; NumValue = 0; Sub = None }
-    { Id = "two"; Value = "another"; NumValue = 10; Sub = Some { Foo = "green"; Bar = "blue" } }
-    { Id = "three"; Value = ""; NumValue = 4; Sub = None }
-    { Id = "four"; Value = "purple"; NumValue = 17; Sub = Some { Foo = "green"; Bar = "red" } }
-    { Id = "five"; Value = "purple"; NumValue = 18; Sub = None }
-]
-
 /// Load a table with the test documents
 let loadDocs () = backgroundTask {
-    for doc in documents do do! insert SqliteDb.TableName doc
+    for doc in testDocuments do do! insert SqliteDb.TableName doc
 }
 
 /// Integration tests for the Configuration module of the SQLite library
@@ -144,32 +135,6 @@ let configurationTests = testList "Configuration" [
         finally
             Configuration.useConnectionString "Data Source=:memory:"
     }
-    test "useSerializer succeeds" {
-        try
-            Configuration.useSerializer
-                { new IDocumentSerializer with
-                    member _.Serialize<'T>(it: 'T) : string = """{"Overridden":true}"""
-                    member _.Deserialize<'T>(it: string) : 'T = Unchecked.defaultof<'T>
-                }
-            
-            let serialized = Configuration.serializer().Serialize { Foo = "howdy"; Bar = "bye"}
-            Expect.equal serialized """{"Overridden":true}""" "Specified serializer was not used"
-            
-            let deserialized = Configuration.serializer().Deserialize<obj> """{"Something":"here"}"""
-            Expect.isNull deserialized "Specified serializer should have returned null"
-        finally
-            Configuration.useSerializer DocumentSerializer.``default``
-    }
-    test "serializer returns configured serializer" {
-        Expect.isTrue (obj.ReferenceEquals(DocumentSerializer.``default``, Configuration.serializer ()))
-            "Serializer should have been the same"
-    }
-    test "useIdField / idField succeeds" {
-        Expect.equal (Configuration.idField ()) "Id" "The default configured ID field was incorrect"
-        Configuration.useIdField "id"
-        Expect.equal (Configuration.idField ()) "id" "useIdField did not set the ID field"
-        Configuration.useIdField "Id"
-    }
 ]
 
 /// Integration tests for the Custom module of the SQLite library
@@ -309,6 +274,68 @@ let documentTests = testList "Document" [
                     insert SqliteDb.TableName {emptyDoc with Id = "test" } |> Async.AwaitTask |> Async.RunSynchronously)
                 "An exception should have been raised for duplicate document ID insert"
         }
+        testTask "succeeds when adding a numeric auto ID" {
+            try
+                Configuration.useAutoIdStrategy Number
+                Configuration.useIdField "Key"
+                use! db = SqliteDb.BuildDb()
+                let! before = Count.all SqliteDb.TableName
+                Expect.equal before 0L "There should be no documents in the table"
+                
+                do! insert SqliteDb.TableName { Key = 0; Text = "one" }
+                do! insert SqliteDb.TableName { Key = 0; Text = "two" }
+                do! insert SqliteDb.TableName { Key = 77; Text = "three" }
+                do! insert SqliteDb.TableName { Key = 0; Text = "four" }
+                
+                let! after = Find.allOrdered<NumIdDocument> SqliteDb.TableName [ Field.Named "Key" ]
+                Expect.hasLength after 4 "There should have been 4 documents returned"
+                Expect.equal (after |> List.map _.Key) [ 1; 2; 77; 78 ] "The IDs were not generated correctly"
+            finally
+                Configuration.useAutoIdStrategy Disabled
+                Configuration.useIdField "Id"
+        }
+        testTask "succeeds when adding a GUID auto ID" {
+            try
+                Configuration.useAutoIdStrategy Guid
+                use! db = SqliteDb.BuildDb()
+                let! before = Count.all SqliteDb.TableName
+                Expect.equal before 0L "There should be no documents in the table"
+                
+                do! insert SqliteDb.TableName { emptyDoc with Value = "one" }
+                do! insert SqliteDb.TableName { emptyDoc with Value = "two" }
+                do! insert SqliteDb.TableName { emptyDoc with Id = "abc123"; Value = "three" }
+                do! insert SqliteDb.TableName { emptyDoc with Value = "four" }
+                
+                let! after = Find.all<JsonDocument> SqliteDb.TableName
+                Expect.hasLength after 4 "There should have been 4 documents returned"
+                Expect.hasCountOf after 3u (fun doc -> doc.Id.Length = 32) "Three of the IDs should have been GUIDs"
+                Expect.hasCountOf after 1u (fun doc -> doc.Id = "abc123") "The provided ID should have been used as-is"
+            finally
+                Configuration.useAutoIdStrategy Disabled
+        }
+        testTask "succeeds when adding a RandomString auto ID" {
+            try
+                Configuration.useAutoIdStrategy RandomString
+                Configuration.useIdStringLength 44
+                use! db = SqliteDb.BuildDb()
+                let! before = Count.all SqliteDb.TableName
+                Expect.equal before 0L "There should be no documents in the table"
+                
+                do! insert SqliteDb.TableName { emptyDoc with Value = "one" }
+                do! insert SqliteDb.TableName { emptyDoc with Value = "two" }
+                do! insert SqliteDb.TableName { emptyDoc with Id = "abc123"; Value = "three" }
+                do! insert SqliteDb.TableName { emptyDoc with Value = "four" }
+                
+                let! after = Find.all<JsonDocument> SqliteDb.TableName
+                Expect.hasLength after 4 "There should have been 4 documents returned"
+                Expect.hasCountOf
+                    after 3u (fun doc -> doc.Id.Length = 44)
+                    "Three of the IDs should have been 44-character random strings"
+                Expect.hasCountOf after 1u (fun doc -> doc.Id = "abc123") "The provided ID should have been used as-is"
+            finally
+                Configuration.useAutoIdStrategy Disabled
+                Configuration.useIdStringLength 16
+        }
     ]
     testList "save" [
         testTask "succeeds when a document is inserted" {

src/Tests/Types.fs

@@ -1,5 +1,9 @@
 module Types
 
+type NumIdDocument =
+    { Key: int
+      Text: string }
+
 type SubDocument =
     { Foo: string
       Bar: string }

src/package.sh

@@ -1,13 +1,16 @@
 #!/bin/bash
 
 echo --- Package Common library
+rm Common/bin/Release/BitBadger.Documents.Common.*.nupkg || true
 dotnet pack Common/BitBadger.Documents.Common.fsproj -c Release
 cp Common/bin/Release/BitBadger.Documents.Common.*.nupkg .
 
 echo --- Package PostgreSQL library
+rm Postgres/bin/Release/BitBadger.Documents.Postgres*.nupkg || true
 dotnet pack Postgres/BitBadger.Documents.Postgres.fsproj -c Release
 cp Postgres/bin/Release/BitBadger.Documents.Postgres.*.nupkg .
 
 echo --- Package SQLite library
+rm Sqlite/bin/Release/BitBadger.Documents.Sqlite*.nupkg || true
 dotnet pack Sqlite/BitBadger.Documents.Sqlite.fsproj -c Release
 cp Sqlite/bin/Release/BitBadger.Documents.Sqlite.*.nupkg .