- Add Transform Hooks

Author: NinjaRocks

src/Schemio.Core/BaseTransformer.cs

@@ -3,7 +3,7 @@
 namespace Schemio.Core
 
 {
-    public abstract class BaseTransformer<TQueryResult, TEntity> : ITransformer, ITransformerContext, ITransformerQueryResult
+    public abstract class BaseTransformer<TQueryResult, TEntity> : ITransformer, ITransformerContext, ITransformerQueryResult, ITransformerHooks
         where TEntity : IEntity
         where TQueryResult : IQueryResult
     {
@@ -39,5 +39,25 @@ public void Transform(IQueryResult queryResult, IEntity entity)
         /// <param name="queryResult">Query Result</param>
         /// <param name="entity">Entity</param>
         public abstract void Transform(TQueryResult queryResult, TEntity entity);
+
+        /// <summary>
+        /// Pre-transform method that can be used to perform any pre-transformation logic if needed.
+        /// </summary>
+        /// <param name="context"></param>
+        public virtual void PreTransform(PreTransformContext context)
+        {
+            // This method can be used to perform any pre-transformation logic if needed.
+            // For example, you could log the query result data or modify it before transformation.
+        }
+
+        /// <summary>
+        /// Post-transform method that can be used to perform any post-transformation logic if needed.
+        /// </summary>
+        /// <param name="context"></param>
+        public virtual void PostTransform(PostTransformContext context)
+        {
+            // This method can be used to perform any post-transformation logic if needed.
+            // For example, you could log the transformed entity or perform additional processing.
+        }
     }
 }

src/Schemio.Core/Helpers/EnumerableExtentions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 
 namespace Schemio.Core.Helpers
@@ -8,12 +9,24 @@ public static class EnumerableExtentions
     {
         public static void Each<T>(this IEnumerable<T> enumerable, Action<T> action)
         {
+            if (enumerable == null)
+                throw new ArgumentNullException(nameof(enumerable), "Enumerable cannot be null");
+
+            if (action == null)
+                throw new ArgumentNullException(nameof(action), "Action cannot be null");
+
             foreach (var item in enumerable)
                 action(item);
         }
 
         public static string ToCSV<T>(this IEnumerable<T> instance, char separator)
         {
+            if (instance == null)
+                return null;
+
+            if (!instance.Any())
+                return string.Empty;
+
             StringBuilder csv;
             if (instance != null)
             {
@@ -26,6 +39,9 @@ public static string ToCSV<T>(this IEnumerable<T> instance, char separator)
 
         public static string ToCSV<T>(this IEnumerable<T> instance)
         {
+            if (instance == null)
+                return null;
+
             return instance.ToCSV(',');
         }
     }

src/Schemio.Core/Helpers/Xml/XmlHelper.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Text;
 using System.Xml;
 using System.Xml.Serialization;
@@ -8,6 +9,12 @@ public static class XmlHelper
     {
         public static string SerializeToXml<T>(T value, XmlSerializerNamespaces namespaces, XmlWriterSettings settings)
         {
+            if (value == null)
+                throw new ArgumentNullException(nameof(value), "Value cannot be null");
+
+            if (settings == null)
+                throw new ArgumentNullException(nameof(settings), "Settings cannot be null");
+
             var xmlStr = new StringBuilder();
             var x = new XmlSerializer(typeof(T));
 

src/Schemio.Core/ISchemioOptions.cs

@@ -0,0 +1,53 @@
+using System;
+
+namespace Schemio.Core
+{
+    /// <summary>
+    /// Interface for Schemio options builder.
+    /// </summary>
+    public interface ISchemioOptions
+    {
+        /// <summary>
+        /// Register a query engine.
+        /// </summary>
+        /// <param name="queryEngines"></param>
+        /// <returns></returns>
+        ISchemioOptions WithEngine(Func<IServiceProvider, IQueryEngine> queryEngines);
+
+        /// <summary>
+        /// Register a query engine of type <typeparamref name="TEngine"/>.
+        /// </summary>
+        /// <typeparam name="TEngine"></typeparam>
+        /// <returns></returns>
+        ISchemioOptions WithEngine<TEngine>() where TEngine : IQueryEngine;
+
+        /// <summary>
+        /// Register an array of query engines.
+        /// </summary>
+        /// <param name="queryEngines"></param>
+        /// <returns></returns>
+        ISchemioOptions WithEngines(Func<IServiceProvider, IQueryEngine[]> queryEngines);
+
+        /// <summary>
+        /// Register an instance of ISchemaPathMatcher. Default is XPathMatcher.
+        /// </summary>
+        /// <param name="pathMatcher"></param>
+        /// <returns></returns>
+        ISchemioOptions WithPathMatcher(Func<IServiceProvider, ISchemaPathMatcher> pathMatcher);
+
+        /// <summary>
+        /// Register an instance of EntityConfiguration<typeparamref name="TEntity"/>.
+        /// </summary>
+        /// <typeparam name="TEntity"></typeparam>
+        /// <param name="entityConfiguration"></param>
+        /// <returns></returns>
+        ISchemioOptions WithEntityConfiguration<TEntity>(Func<IServiceProvider, IEntityConfiguration<TEntity>> entityConfiguration)
+            where TEntity : class, IEntity, new();
+
+        /// <summary>
+        /// Set Schemio to silent mode. In this mode, no exceptions will be thrown if there are no entity configurations or query engines registered.
+        /// </summary>
+        /// <returns></returns>
+        ISchemioOptions InSilentMode();
+    }
+}

src/Schemio.Core/ITransformerHooks.cs

@@ -0,0 +1,20 @@
+namespace Schemio.Core
+{
+    /// <summary>
+    /// Transformer hooks interface to allow pre and post transformation actions.
+    /// </summary>
+    public interface ITransformerHooks
+    {
+        /// <summary>
+        /// Pre-transform hook to perform actions before the transformation.
+        /// </summary>
+        /// <param name="context"></param>
+        void PreTransform(PreTransformContext context);
+
+        /// <summary>
+        /// Post-transform hook to perform actions after the transformation.
+        /// </summary>
+        /// <param name="context"></param>
+        void PostTransform(PostTransformContext context);
+    }
+}

src/Schemio.Core/Impl/EntityBuilder.cs

@@ -44,15 +44,50 @@ public T Build(IDataContext context, IList<IQueryResult> queryResults)
 
                 foreach (var queryResult in queryResults)
                     transformers.Where(transformer => IsMatch(((ITransformerQueryResult)transformer).SupportedQueryResult, queryResult.GetType())).ToList()
-                        .ForEach(supportedtransformer => supportedtransformer?.Transform(queryResult, entity));
+                        .ForEach(transformer => TransformWithHooks(new TransformContext(context, queryResult, transformer, entity)));
             }
 
             return entity;
         }
 
-        private bool IsMatch(Type transformer, Type queryResult)
+        /// <summary>
+        /// Checks if the transformer query result type matches the query result type.
+        /// </summary>
+        /// <param name="transformerQueryResult"></param>
+        /// <param name="queryResult"></param>
+        /// <returns></returns>
+        private bool IsMatch(Type transformerQueryResult, Type queryResult)
+        {
+            return transformerQueryResult == queryResult;
+        }
+
+        /// <summary>
+        /// Transform method that includes hooks for pre and post transformation.
+        /// </summary>
+        /// <param name="context"></param>
+        private void TransformWithHooks(TransformContext context)
         {
-            return transformer == queryResult;
+            // Create a pre-transform context to pass the data before transformation.
+            var preTransformContext = new PreTransformContext(context);
+            // Call the pre-transform method with the context.
+            if (context.Transformer is ITransformerHooks transformerPreHook)
+                transformerPreHook.PreTransform(preTransformContext);
+
+            // If the pre-transform context is cancelled, skip the transformation.
+            if (!preTransformContext.IsCancelled)
+                context.Transformer.Transform(context.QueryResult, context.Entity);
+
+            // Post-transform hook can be used to perform any post-transformation logic if needed.
+            if (context.Transformer is ITransformerHooks transformerPostHook)
+            {
+                // Create a post-transform context to pass the data after transformation.
+                var postTransformContext = new PostTransformContext(context);
+                // Call the post-transform method with the context.
+                transformerPostHook.PostTransform(postTransformContext);
+                // If the post-transform context is repeat, transform again.
+                if (postTransformContext.IsRepeat)
+                    context.Transformer.Transform(context.QueryResult, context.Entity);
+            }
         }
     }
 }

src/Schemio.Core/PostTransformContext.cs

@@ -0,0 +1,27 @@
+namespace Schemio.Core
+{
+    public class PostTransformContext : TransformContext
+    {
+        /// <summary>
+        /// Indicates whether the transformation needs to be repeated.
+        /// </summary>
+        internal bool IsRepeat { get; private set; }
+
+        /// <summary>
+        /// Repeat the transformation process.
+        /// </summary>
+        public void Repeat() => IsRepeat = true;
+
+        /// <summary>
+        /// Creates a new instance of PostTransformContext with the provided parameters.
+        /// </summary>
+        /// <summary>
+        /// Creates a new instance of PreTransformContext with the provided parameters.
+        /// </summary>
+        /// <param name="context">TransformContext</param>
+        public PostTransformContext(TransformContext context) :
+            base(context.DataContext, context.QueryResult, context.Transformer, context.Entity)
+        {
+        }
+    }
+}

src/Schemio.Core/PreTransformContext.cs

@@ -0,0 +1,24 @@
+namespace Schemio.Core
+{
+    public class PreTransformContext : TransformContext
+    {
+        /// <summary>
+        /// Indicates whether the transformation has been cancelled.
+        /// </summary>
+        internal bool IsCancelled { get; private set; }
+
+        /// <summary>
+        /// Cancels the transformation process.
+        /// </summary>
+        public void Cancel() => IsCancelled = true;
+
+        /// <summary>
+        /// Creates a new instance of PreTransformContext with the provided parameters.
+        /// </summary>
+        /// <param name="context">TransformContext</param>
+        public PreTransformContext(TransformContext context) :
+            base(context.DataContext, context.QueryResult, context.Transformer, context.Entity)
+        {
+        }
+    }
+}

src/Schemio.Core/QueryComparer.cs

@@ -6,9 +6,24 @@ public class QueryComparer : IEqualityComparer<IQuery>
     {
         #region IQuery
 
-        public bool Equals(IQuery x, IQuery y) => x.GetType() == y.GetType();
+        public bool Equals(IQuery x, IQuery y)
+        {
+            if (x == null && y == null)
+                return true;
 
-        public int GetHashCode(IQuery obj) => obj.GetType().GetHashCode();
+            if (x == null || y == null)
+                return false;
+
+            return x.GetType() == y.GetType();
+        }
+
+        public int GetHashCode(IQuery obj)
+        {
+            if (obj == null)
+                throw new System.ArgumentNullException(nameof(obj), "Query object cannot be null");
+
+            return obj.GetType().GetHashCode();
+        }
 
         #endregion IQuery
     }