feat: Fully support .NET Standard on various platforms

Parse.Tests/ConfigTests.cs

@@ -61,7 +61,7 @@ public void TestCurrentConfig()
         public void TestToJSON()
         {
             IDictionary<string, object> expectedJson = new Dictionary<string, object> { { "params", new Dictionary<string, object> { { "testKey", "testValue" } } } };
-            Assert.AreEqual(JsonConvert.SerializeObject((Client.GetCurrentConfiguration() as IJsonConvertible).ConvertToJSON()), JsonConvert.SerializeObject(expectedJson));
+            Assert.AreEqual(JsonConvert.SerializeObject((Client.GetCurrentConfiguration() as IJsonConvertible).ConvertToJson()), JsonConvert.SerializeObject(expectedJson));
         }
 
         [TestMethod]

Parse.Tests/UserTests.cs

@@ -602,7 +602,7 @@ public Task TestLink()
             hub.ObjectController = mockObjectController.Object;
             hub.CurrentUserController = new Mock<IParseCurrentUserController> { }.Object;
 
-            return user.LinkWithAsync("parse", new Dictionary<string, object> { }, CancellationToken.None).ContinueWith(task =>
+            return user.LinkToServiceAsync("parse", new Dictionary<string, object> { }, CancellationToken.None).ContinueWith(task =>
             {
                 Assert.IsFalse(task.IsFaulted);
                 Assert.IsFalse(task.IsCanceled);
@@ -656,7 +656,7 @@ public Task TestUnlink()
             hub.ObjectController = mockObjectController.Object;
             hub.CurrentUserController = mockCurrentUserController.Object;
 
-            return user.UnlinkFromAsync("parse", CancellationToken.None).ContinueWith(task =>
+            return user.UnlinkFromServiceAsync("parse", CancellationToken.None).ContinueWith(task =>
             {
                 Assert.IsFalse(task.IsFaulted);
                 Assert.IsFalse(task.IsCanceled);
@@ -710,7 +710,7 @@ public Task TestUnlinkNonCurrentUser()
             hub.ObjectController = mockObjectController.Object;
             hub.CurrentUserController = mockCurrentUserController.Object;
 
-            return user.UnlinkFromAsync("parse", CancellationToken.None).ContinueWith(task =>
+            return user.UnlinkFromServiceAsync("parse", CancellationToken.None).ContinueWith(task =>
             {
                 Assert.IsFalse(task.IsFaulted);
                 Assert.IsFalse(task.IsCanceled);
@@ -747,7 +747,7 @@ public Task TestLogInWith()
 
             hub.UserController = mockController.Object;
 
-            return client.LogInWithAsync("parse", new Dictionary<string, object> { }, CancellationToken.None).ContinueWith(task =>
+            return client.AuthenticateWithServiceAsync("parse", new Dictionary<string, object> { }, CancellationToken.None).ContinueWith(task =>
             {
                 Assert.IsFalse(task.IsFaulted);
                 Assert.IsFalse(task.IsCanceled);

Parse/Abstractions/Infrastructure/IJsonConvertible.cs

@@ -11,6 +11,6 @@ public interface IJsonConvertible
         /// Converts the object to a data structure that can be converted to JSON.
         /// </summary>
         /// <returns>An object to be JSONified.</returns>
-        IDictionary<string, object> ConvertToJSON();
+        IDictionary<string, object> ConvertToJson();
     }
 }

Parse/Abstractions/Infrastructure/IServiceHubBuilder.cs

@@ -0,0 +1,11 @@
+#nullable enable
+
+namespace Parse.Abstractions.Infrastructure
+{
+    // ALTERNATE NAME: IServiceHubRebuilder, IServiceHubConstructor, IServiceHubBuilder, IServiceHubStacker, ISericeHubCreator, IClient, IDataContainmentHub, IResourceContainmentHub, IDataContainer, IServiceHubComposer
+
+    public interface IServiceHubBuilder
+    {
+        public IServiceHub BuildHub(IMutableServiceHub? serviceHub = default, IServiceHub? extension = default, params IServiceHubMutator[] mutators);
+    }
+}

Parse/Abstractions/Infrastructure/IServiceHubCloner.cs

@@ -1,7 +1,17 @@
 namespace Parse.Abstractions.Infrastructure
 {
+    /// <summary>
+    /// Generates an <see cref="IServiceHub"/> as a clone of another. This clone could be mutated.
+    /// </summary>
     public interface IServiceHubCloner
     {
-        public IServiceHub BuildHub(in IServiceHub reference, IServiceHubComposer composer, params IServiceHubMutator[] requestedMutators);
+        /// <summary>
+        /// Clones <paramref name="hub"/>, via the <paramref name="builder"/> if needed, and should execute the <paramref name="mutators"/>. The clone could be observed in a mutated state versus <paramref name="hub"/>.
+        /// </summary>
+        /// <param name="hub">The hub to use as a reference or combination extension to new hub.</param>
+        /// <param name="builder">The builder which could be used to create the clone.</param>
+        /// <param name="mutators">Additional mutators to execute on the cloned hub.</param>
+        /// <returns>A service hub which could be both based on <paramref name="hub"/>, and observed in a mutated state versus <paramref name="hub"/>.</returns>
+        public IServiceHub CloneHub(in IServiceHub hub, IServiceHubBuilder builder, params IServiceHubMutator[] mutators);
     }
 }

Parse/Abstractions/Infrastructure/IServiceHubMutator.cs

@@ -1,9 +1,11 @@
+using System.Collections.Generic;
+
 namespace Parse.Abstractions.Infrastructure
 {
     // IServiceHubComposer, IServiceHubMutator, IServiceHubConfigurator, IClientConfigurator, IServiceConfigurationLayer
 
     /// <summary>
-    /// A class which makes a deliberate mutation to a service.
+    /// A definition of a deliberate mutation to a service hub.
     /// </summary>
     public interface IServiceHubMutator
     {
@@ -12,11 +14,17 @@ public interface IServiceHubMutator
         /// </summary>
         bool Valid { get; }
 
+        //IServiceHubMutator[] Mutators => new[] { this };
+
+        // customHub, mutableHub, slice, target
+        // combinedHub, stackedHub, overallHub, resultantHub, composedHub
+
         /// <summary>
         /// A method which mutates an <see cref="IMutableServiceHub"/> implementation instance.
         /// </summary>
-        /// <param name="target">The target <see cref="IMutableServiceHub"/> implementation instance</param>
-        /// <param name="composedHub">A hub which the <paramref name="target"/> is composed onto that should be used when <see cref="Mutate(ref IMutableServiceHub, in IServiceHub)"/> needs to access services.</param>
-        void Mutate(ref IMutableServiceHub target, in IServiceHub composedHub);
+        /// <param name="mutableHub">The target <see cref="IMutableServiceHub"/> implementation instance</param>
+        /// <param name="consumableHub">A hub which the <paramref name="mutableHub"/> is combined onto that should be used when <see cref="Mutate(ref IMutableServiceHub, in IServiceHub)"/> needs to access services.</param>
+        /// <param name="futureMutators">The mutators that will be executed after this one.</param>
+        void Mutate(ref IMutableServiceHub mutableHub, in IServiceHub consumableHub, Stack<IServiceHubMutator> futureMutators);
     }
 }

Parse/Abstractions/Platform/Authentication/IParseAuthenticationProvider.cs

@@ -4,6 +4,9 @@
 
 namespace Parse.Abstractions.Platform.Authentication
 {
+    /// <summary>
+    /// An authenticator service for the Parse SDK.
+    /// </summary>
     public interface IParseAuthenticationProvider
     {
         /// <summary>
@@ -33,6 +36,6 @@ public interface IParseAuthenticationProvider
         /// Provides a unique name for the type of authentication the provider does.
         /// For example, the FacebookAuthenticationProvider would return "facebook".
         /// </summary>
-        string AuthType { get; }
+        string Name { get; }
     }
 }

Parse/Infrastructure/AbsoluteCacheLocationMutator.cs

@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 using Parse.Abstractions.Infrastructure;
 
 namespace Parse.Infrastructure
@@ -12,17 +14,11 @@ public class AbsoluteCacheLocationMutator : IServiceHubMutator
         /// </summary>
         public string CustomAbsoluteCacheFilePath { get; set; }
 
-        /// <summary>
         /// <inheritdoc/>
-        /// </summary>
         public bool Valid => CustomAbsoluteCacheFilePath is { };
 
-        /// <summary>
         /// <inheritdoc/>
-        /// </summary>
-        /// <param name="target"><inheritdoc/></param>
-        /// <param name="composedHub"><inheritdoc/></param>
-        public void Mutate(ref IMutableServiceHub target, in IServiceHub composedHub)
+        public void Mutate(ref IMutableServiceHub target, in IServiceHub composedHub, Stack<IServiceHubMutator> futureMutators)
         {
             if ((target as IServiceHub).CacheController is IDiskFileCacheController { } diskFileCacheController)
             {

Parse/Infrastructure/ConcurrentUserServiceHubCloner.cs

@@ -1,19 +1,33 @@
+using System.Collections.Generic;
 using System.Linq;
 using Parse.Abstractions.Infrastructure;
 using Parse.Platform.Users;
 
 namespace Parse.Infrastructure
 {
+    /// <summary>
+    /// Makes it so that <see cref="ParseClient"/> clones can be made each with a reset <see cref="IServiceHub.CurrentUserController"/>, but otherwise identical services unless modified.
+    /// </summary>
     public class ConcurrentUserServiceHubCloner : IServiceHubCloner, IServiceHubMutator
     {
+        /// <inheritdoc/>
         public bool Valid { get; } = true;
 
-        public IServiceHub BuildHub(in IServiceHub reference, IServiceHubComposer composer, params IServiceHubMutator[] requestedMutators) => composer.BuildHub(default, reference, requestedMutators.Concat(new[] { this }).ToArray());
+        /// <summary>
+        /// Mutators which need to be executed on each new hub for a user.
+        /// </summary>
+        public List<IServiceHubMutator> BoundMutators { get; set; } = new List<IServiceHubMutator> { };
 
-        public void Mutate(ref IMutableServiceHub target, in IServiceHub composedHub)
+        /// <inheritdoc/>
+        public IServiceHub CloneHub(in IServiceHub hub, IServiceHubBuilder builder, params IServiceHubMutator[] mutators) => builder.BuildHub(default, hub, mutators.Concat(new[] { this }).ToArray());
+
+        /// <inheritdoc/>
+        public void Mutate(ref IMutableServiceHub mutableHub, in IServiceHub consumableHub, Stack<IServiceHubMutator> futureMutators)
         {
-            target.Cloner = this;
-            target.CurrentUserController = new ParseCurrentUserController(new TransientCacheController { }, composedHub.ClassController, composedHub.Decoder);
+            mutableHub.Cloner = this;
+            mutableHub.CurrentUserController = new ParseCurrentUserController(new TransientCacheController { }, consumableHub.ClassController, consumableHub.Decoder);
+
+            BoundMutators.ForEach(mutator => futureMutators.Push(mutator));
         }
     }
 }

Parse/Infrastructure/Data/ParseDataEncoder.cs

@@ -32,7 +32,7 @@ public abstract class ParseDataEncoder
                 ["base64"] = Convert.ToBase64String(bytes)
             },
             ParseObject { } entity => EncodeObject(entity),
-            IJsonConvertible { } jsonConvertible => jsonConvertible.ConvertToJSON(),
+            IJsonConvertible { } jsonConvertible => jsonConvertible.ConvertToJson(),
             { } when Conversion.As<IDictionary<string, object>>(value) is { } dictionary => dictionary.ToDictionary(pair => pair.Key, pair => Encode(pair.Value, serviceHub)),
             { } when Conversion.As<IList<object>>(value) is { } list => EncodeList(list, serviceHub),
 

Parse/Infrastructure/FacebookAuthenticationMutator.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using Parse.Abstractions.Infrastructure;
+using Parse.Infrastructure.Utilities;
+
+namespace Parse.Infrastructure
+{
+    /// <summary>
+    /// Enables Facebook authentication on the service hub.
+    /// </summary>
+    public class FacebookAuthenticationMutator : IServiceHubMutator
+    {
+        /// <inheritdoc/>
+        public bool Valid => Caller is { Length: > 0 };
+
+        /// <summary>
+        /// The identifier to make API calls to Facebook with. This is in the Facebook Developer Dashboard as some variant of "Application ID" or "API Key".
+        /// </summary>
+        public string Caller { get; set; }
+
+        /// <inheritdoc/>
+        public void Mutate(ref IMutableServiceHub mutableHub, in IServiceHub consumableHub, Stack<IServiceHubMutator> futureMutators) => mutableHub.InitializeFacebookAuthenticationProvider(Caller);
+    }
+}

Parse/Infrastructure/MetadataMutator.cs

@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 using Parse.Abstractions.Infrastructure;
 
 namespace Parse.Infrastructure
@@ -13,10 +15,11 @@ public class MetadataMutator : MetadataController, IServiceHubMutator
         public bool Valid => this is { EnvironmentData: { OSVersion: { }, Platform: { }, TimeZone: { } }, HostManifestData: { Identifier: { }, Name: { }, ShortVersion: { }, Version: { } } };
 
         /// <summary>
-        /// Sets the <paramref name="target"/> to the <see cref="MetadataMutator"/> instance.
+        /// Sets the <paramref name="mutableHub"/>'s <see cref="IServiceHub.MetadataController"/> to the <see cref="MetadataMutator"/> instance.
         /// </summary>
-        /// <param name="target">The <see cref="IMutableServiceHub"/> to compose the information onto.</param>
-        /// <param name="referenceHub">Thhe <see cref="IServiceHub"/> to use if a default service instance is required.</param>
-        public void Mutate(ref IMutableServiceHub target, in IServiceHub referenceHub) => target.MetadataController = this;
+        /// <param name="mutableHub">The <see cref="IMutableServiceHub"/> to compose the information onto.</param>
+        /// <param name="consumableHub">The <see cref="IServiceHub"/> to use if a default service instance is required.</param>
+        /// <param name="futureMutators">The mutators that will be executed after this one.</param>
+        public void Mutate(ref IMutableServiceHub mutableHub, in IServiceHub consumableHub, Stack<IServiceHubMutator> futureMutators) => mutableHub.MetadataController = this;
     }
 }

Parse/Infrastructure/RelativeCacheLocationMutator.cs

@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 using Parse.Abstractions.Infrastructure;
 
 namespace Parse.Infrastructure
@@ -12,17 +14,11 @@ public class RelativeCacheLocationMutator : IServiceHubMutator
         /// </summary>
         public IRelativeCacheLocationGenerator RelativeCacheLocationGenerator { get; set; }
 
-        /// <summary>
         /// <inheritdoc/>
-        /// </summary>
         public bool Valid => RelativeCacheLocationGenerator is { };
 
-        /// <summary>
         /// <inheritdoc/>
-        /// </summary>
-        /// <param name="target"><inheritdoc/></param>
-        /// <param name="referenceHub"><inheritdoc/></param>
-        public void Mutate(ref IMutableServiceHub target, in IServiceHub referenceHub) => target.CacheController = (target as IServiceHub).CacheController switch
+        public void Mutate(ref IMutableServiceHub target, in IServiceHub referenceHub, Stack<IServiceHubMutator> futureMutators) => target.CacheController = (target as IServiceHub).CacheController switch
         {
             null => new CacheController { RelativeCacheFilePath = RelativeCacheLocationGenerator.GetRelativeCacheFilePath(referenceHub) },
             IDiskFileCacheController { } controller => (Controller: controller, controller.RelativeCacheFilePath = RelativeCacheLocationGenerator.GetRelativeCacheFilePath(referenceHub)).Controller,