Added the json config along with fix on source generator rules to strict on cron expression 6th segment

Author: arcenox

README.md

@@ -120,7 +120,7 @@ public class CleanupJobs(ICleanUpService cleanUpService)
 {
     private readonly ICleanUpService _cleanUpService = cleanUpService;
 
-    [TickerFunction(functionName: "CleanupLogs", cronExpression: "0 0 * * *" )]
+    [TickerFunction(functionName: "CleanupLogs", cronExpression: "0 0 0 * * *" )]
     public asynt Task CleanupLogs(TickerFunctionContext<string> tickerContext, CancellationToken cancellationToken)
     {
         var logFileName = tickerContext.Request; // output cleanup_example_file.txt
@@ -131,27 +131,20 @@ public class CleanupJobs(ICleanUpService cleanUpService)
 
 > This uses a cron expression to run daily at midnight.
 
-#### 📅 Cron Expression Formats
+#### 📅 Cron Expression Format
 
-TickerQ supports both **5-part** and **6-part** cron expressions:
+TickerQ uses **6-part** cron expressions with seconds precision:
 
-**5-part format (standard):**
-```
-minute hour day month day-of-week
-```
-Examples:
-- `"0 0 * * *"` - Daily at midnight
-- `"0 */6 * * *"` - Every 6 hours
-- `"30 14 * * 1"` - Every Monday at 2:30 PM
-
-**6-part format (with seconds):**
 ```
 second minute hour day month day-of-week
 ```
+
 Examples:
 - `"0 0 0 * * *"` - Daily at midnight (00:00:00)
 - `"30 0 0 * * *"` - Daily at 00:00:30 (30 seconds past midnight)
 - `"0 0 */2 * * *"` - Every 2 hours on the hour
+- `"0 0 */6 * * *"` - Every 6 hours
+- `"0 30 14 * * 1"` - Every Monday at 2:30 PM
 - `"*/10 * * * * *"` - Every 10 seconds
 
 ---
@@ -180,10 +173,10 @@ Schedule Cron Ticker:
 await _cronTickerManager.AddAsync(new CronTicker
 {
     Function = "CleanupLogs",
-    Expression = "0 */6 * * *", // Every 6 hours (5-part format)
-    // Or use 6-part format with seconds:
-    // Expression = "0 0 */6 * * *", // Every 6 hours at :00:00
+    Expression = "0 0 */6 * * *", // Every 6 hours at :00:00
+    // Other examples:
     // Expression = "*/30 * * * * *", // Every 30 seconds
+    // Expression = "0 0 0 * * *", // Daily at midnight
     Request = TickerHelper.CreateTickerRequest<string>("cleanup_example_file.txt"),
     Retries = 2,
     RetryIntervals = new[] { 60, 300 }

src/TickerQ.Dashboard/DashboardOptionsBuilder.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Text;
+using System.Text.Json;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Cors.Infrastructure;
 using TickerQ.Dashboard.Authentication;
@@ -20,6 +21,12 @@ public class DashboardOptionsBuilder
     public Action<IApplicationBuilder> PreDashboardMiddleware { get; set; }
     public Action<IApplicationBuilder> PostDashboardMiddleware { get; set; }
 
+    /// <summary>
+    /// JsonSerializerOptions specifically for Dashboard API endpoints.
+    /// Separate from request serialization options to prevent user configuration from breaking dashboard APIs.
+    /// </summary>
+    internal JsonSerializerOptions DashboardJsonOptions { get; set; }
+    
     public void SetCorsPolicy(Action<CorsPolicyBuilder> corsPolicyBuilder)
         => CorsPolicyBuilder = corsPolicyBuilder;
 
@@ -74,6 +81,19 @@ public DashboardOptionsBuilder WithSessionTimeout(int minutes)
         return this;
     }
 
+    /// <summary>
+    /// Configure JSON serialization options for Dashboard API endpoints.
+    /// These are separate from request serialization to maintain dashboard integrity.
+    /// </summary>
+    /// <param name="configure">Action to configure JsonSerializerOptions for dashboard APIs</param>
+    /// <returns>The DashboardOptionsBuilder for method chaining</returns>
+    public DashboardOptionsBuilder ConfigureDashboardJsonOptions(Action<JsonSerializerOptions> configure)
+    {
+        DashboardJsonOptions ??= new JsonSerializerOptions();
+        configure?.Invoke(DashboardJsonOptions);
+        return this;
+    }
+    
     /// <summary>Validate the authentication configuration</summary>
     internal void Validate()
     {

src/TickerQ.Dashboard/DependencyInjection/ServiceCollectionExtensions.cs

@@ -9,6 +9,7 @@
 using Microsoft.Extensions.FileProviders;
 using TickerQ.Dashboard.Authentication;
 using TickerQ.Dashboard.Endpoints;
+using TickerQ.Dashboard.Infrastructure;
 using System.Text.Json;
 using System.Text.RegularExpressions;
 using TickerQ.Utilities.Entities;
@@ -21,6 +22,24 @@ internal static void AddDashboardService<TTimeTicker, TCronTicker>(this IService
             where TTimeTicker : TimeTickerEntity<TTimeTicker>, new()
             where TCronTicker : CronTickerEntity, new()
         {
+            // Configure default Dashboard JSON options if not already configured
+            if (config.DashboardJsonOptions == null)
+            {
+                config.DashboardJsonOptions = new JsonSerializerOptions
+                {
+                    PropertyNameCaseInsensitive = true,
+                    Converters = { new StringToByteArrayConverter() }
+                };
+            }
+            else
+            {
+                // Ensure StringToByteArrayConverter is always present
+                if (!config.DashboardJsonOptions.Converters.Any(c => c is StringToByteArrayConverter))
+                {
+                    config.DashboardJsonOptions.Converters.Add(new StringToByteArrayConverter());
+                }
+            }
+            
             // Register the dashboard configuration for DI
             services.AddSingleton(config);
             services.AddSingleton(config.Auth);

src/TickerQ.Dashboard/Endpoints/DashboardEndpoints.cs

@@ -294,6 +294,7 @@ private static async Task<IResult> GetTimeTickersGraphData<TTimeTicker, TCronTic
     private static async Task<IResult> CreateChainJobs<TTimeTicker, TCronTicker>(
         HttpContext context,
         ITimeTickerManager<TTimeTicker> timeTickerManager,
+        DashboardOptionsBuilder dashboardOptions,
         CancellationToken cancellationToken)
         where TTimeTicker : TimeTickerEntity<TTimeTicker>, new()
         where TCronTicker : CronTickerEntity, new()
@@ -302,15 +303,8 @@ private static async Task<IResult> CreateChainJobs<TTimeTicker, TCronTicker>(
         using var reader = new StreamReader(context.Request.Body);
         var jsonString = await reader.ReadToEndAsync(cancellationToken);
 
-        // Create JsonSerializerOptions with our custom converter for this endpoint only
-        var jsonOptions = new JsonSerializerOptions
-        {
-            PropertyNameCaseInsensitive = true,
-            Converters = { new StringToByteArrayConverter() }
-        };
-        
-        // Deserialize with custom converter
-        var chainRoot = JsonSerializer.Deserialize<TTimeTicker>(jsonString, jsonOptions);
+        // Use Dashboard-specific JSON options
+        var chainRoot = JsonSerializer.Deserialize<TTimeTicker>(jsonString, dashboardOptions.DashboardJsonOptions);
 
         var result = await timeTickerManager.AddAsync(chainRoot, cancellationToken);
 

src/TickerQ.Dashboard/Infrastructure/Dashboard/TickerDashboardRepository.cs

@@ -25,18 +25,23 @@ internal class TickerDashboardRepository<TTimeTicker, TCronTicker> : ITickerDash
         private readonly TickerExecutionContext _executionContext;
         private readonly ITimeTickerManager<TTimeTicker>  _timeTickerManager;
         private readonly ITickerClock _clock;
+        private readonly DashboardOptionsBuilder _dashboardOptions;
         public TickerDashboardRepository(
             TickerExecutionContext executionContext,
             ITickerPersistenceProvider<TTimeTicker, TCronTicker> persistenceProvider,
             ITickerQHostScheduler tickerQHostScheduler, 
-            ITickerQNotificationHubSender notificationHubSender, ITimeTickerManager<TTimeTicker> timeTickerManager, ITickerClock clock)
+            ITickerQNotificationHubSender notificationHubSender, 
+            ITimeTickerManager<TTimeTicker> timeTickerManager, 
+            ITickerClock clock,
+            DashboardOptionsBuilder dashboardOptions)
         {
             _persistenceProvider = persistenceProvider ?? throw new ArgumentNullException(nameof(persistenceProvider));
             _tickerQHostScheduler = tickerQHostScheduler ?? throw new ArgumentNullException(nameof(tickerQHostScheduler));
             _notificationHubSender = notificationHubSender ?? throw new ArgumentNullException(nameof(notificationHubSender));
             _timeTickerManager = timeTickerManager;
             _clock = clock ?? throw new ArgumentNullException(nameof(clock));
             _executionContext = executionContext ??  throw new ArgumentNullException(nameof(executionContext));
+            _dashboardOptions = dashboardOptions ?? throw new ArgumentNullException(nameof(dashboardOptions));
         }
 
         public async Task<TTimeTicker[]> GetTimeTickersAsync(CancellationToken cancellationToken)
@@ -669,7 +674,7 @@ public async Task DeleteCronTickerOccurrenceByIdAsync(Guid id, CancellationToken
                     out var functionTypeContext)) return (jsonRequest, 2);
             try
             {
-                JsonSerializer.Deserialize(jsonRequest, functionTypeContext.Item2);
+                JsonSerializer.Deserialize(jsonRequest, functionTypeContext.Item2, _dashboardOptions.DashboardJsonOptions);
                 return (jsonRequest, 1);
             }
             catch
@@ -760,7 +765,7 @@ public async Task UpdateCronTickerAsync(Guid id, UpdateCronTickerRequest request
             // Process the request using the function
             if (!string.IsNullOrWhiteSpace(request.Request))
             {
-                var serializedRequest = JsonSerializer.Deserialize<object>(request.Request);
+                var serializedRequest = JsonSerializer.Deserialize<object>(request.Request, _dashboardOptions.DashboardJsonOptions);
                 cronTicker.Request = TickerHelper.CreateTickerRequest(serializedRequest);
             }
 

src/TickerQ.SourceGenerator/TickerQ.SourceGenerator.csproj

@@ -1,11 +1,15 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
+        <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
         <AssemblyName>TickerQ.SourceGenerator</AssemblyName>
         <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
-        <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.10.0" PrivateAssets="all" />
+        <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="[4.10.0,)"/>
     </ItemGroup>
 </Project>

src/TickerQ.SourceGenerator/Validation/CronValidator.cs

@@ -5,40 +5,31 @@ namespace TickerQ.SourceGenerator.Validation
 {
     public static class CronValidator
     {
-        // Format with seconds (6 parts): seconds, minutes, hours, day, month, day-of-week
-        private static readonly int[] MinValuesArray6Part = { 0, 0, 0, 1, 1, 0 };
-        private static readonly int[] MaxValuesArray6Part = { 59, 59, 23, 31, 12, 6 };
-        
-        // Format without seconds (5 parts): minutes, hours, day, month, day-of-week
-        private static readonly int[] MinValuesArray5Part = { 0, 0, 1, 1, 0 };
-        private static readonly int[] MaxValuesArray5Part = { 59, 23, 31, 12, 6 };
+        // Format with seconds (6 parts only): seconds, minutes, hours, day, month, day-of-week
+        private static readonly int[] MinValues = { 0, 0, 0, 1, 1, 0 };
+        private static readonly int[] MaxValues = { 59, 59, 23, 31, 12, 6 };
 
         // Performance constants
-        private const int MaxPartsCount = 6;
+        private const int RequiredPartsCount = 6;
 
         public static bool IsValidCronExpression(string expression)
         {
             if (string.IsNullOrEmpty(expression)) return false;
 
             // Use Span for efficient string splitting without allocations
             var expressionSpan = expression.AsSpan();
-            var parts = new string[MaxPartsCount];
+            var parts = new string[RequiredPartsCount];
             var partCount = SplitIntoSpan(expressionSpan, parts);
 
-            // Support both 5-part (without seconds) and 6-part (with seconds) cron expressions
-            if (partCount != 5 && partCount != 6) 
+            // Only support 6-part cron expressions with seconds
+            if (partCount != RequiredPartsCount) 
                 return false;
 
-            // Select appropriate min/max values based on part count
-            ReadOnlySpan<int> minSpan = partCount == 6 
-                ? MinValuesArray6Part 
-                : MinValuesArray5Part;
-            
-            ReadOnlySpan<int> maxSpan = partCount == 6 
-                ? MaxValuesArray6Part 
-                : MaxValuesArray5Part;
+            // Validate each part with corresponding min/max values
+            ReadOnlySpan<int> minSpan = MinValues;
+            ReadOnlySpan<int> maxSpan = MaxValues;
 
-            for (int i = 0; i < partCount; i++)
+            for (int i = 0; i < RequiredPartsCount; i++)
             {
                 if (!ValidatePart(parts[i], minSpan[i], maxSpan[i]))
                     return false;

src/TickerQ.Utilities/TickerHelper.cs

@@ -9,6 +9,12 @@ namespace TickerQ.Utilities
     public static class TickerHelper
     {
         private static readonly byte[] GZipSignature = [0x1f, 0x8b, 0x08, 0x00];
+        
+        /// <summary>
+        /// JsonSerializerOptions specifically for ticker request serialization/deserialization.
+        /// Can be configured during application startup via TickerOptionsBuilder.
+        /// </summary>
+        public static JsonSerializerOptions RequestJsonSerializerOptions { get; set; } = new JsonSerializerOptions();
 
         public static byte[] CreateTickerRequest<T>(T data)
         {
@@ -22,7 +28,7 @@ public static byte[] CreateTickerRequest<T>(T data)
             Span<byte> compressedBytes;
             var serialized = data is byte[] bytes
                 ? bytes
-                : JsonSerializer.SerializeToUtf8Bytes(data);
+                : JsonSerializer.SerializeToUtf8Bytes(data, RequestJsonSerializerOptions);
 
             using (var memoryStream = new MemoryStream())
             {
@@ -46,7 +52,7 @@ public static T ReadTickerRequest<T>(byte[] gzipBytes)
         {
             var serializedObject = ReadTickerRequestAsString(gzipBytes);
 
-            return JsonSerializer.Deserialize<T>(serializedObject);
+            return JsonSerializer.Deserialize<T>(serializedObject, RequestJsonSerializerOptions);
         }
 
         public static string ReadTickerRequestAsString(byte[] gzipBytes)

src/TickerQ.Utilities/TickerOptionsBuilder.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Text.Json;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
 using TickerQ.Utilities.Entities;
@@ -28,6 +29,25 @@ public TickerOptionsBuilder<TTimeTicker, TCronTicker> ConfigureScheduler(Action<
             schedulerOptionsBuilder?.Invoke(_schedulerOptions);
             return this;
         }
+
+              
+        /// <summary>
+        /// JsonSerializerOptions specifically for serializing/deserializing ticker requests.
+        /// If not set, default JsonSerializerOptions will be used.
+        /// </summary>
+        internal JsonSerializerOptions RequestJsonSerializerOptions { get; set; }
+        
+        /// <summary>
+        /// Configures the JSON serialization options specifically for ticker request serialization/deserialization.
+        /// </summary>
+        /// <param name="configure">Action to configure JsonSerializerOptions for ticker requests</param>
+        /// <returns>The TickerOptionsBuilder for method chaining</returns>
+        public TickerOptionsBuilder<TTimeTicker, TCronTicker> ConfigureRequestJsonOptions(Action<JsonSerializerOptions> configure)
+        {
+            RequestJsonSerializerOptions ??= new JsonSerializerOptions();
+            configure?.Invoke(RequestJsonSerializerOptions);
+            return this;
+        }
 
         public TickerOptionsBuilder<TTimeTicker, TCronTicker> SetExceptionHandler<THandler>() where THandler : ITickerExceptionHandler
         {

src/TickerQ/DependencyInjection/TickerQServiceExtensions.cs

@@ -32,6 +32,12 @@ public static IServiceCollection AddTickerQ<TTimeTicker, TCronTicker>(this IServ
             var optionInstance = new TickerOptionsBuilder<TTimeTicker,TCronTicker>(tickerExecutionContext, schedulerOptionsBuilder);
             optionsBuilder?.Invoke(optionInstance);
             CronScheduleCache.TimeZoneInfo = schedulerOptionsBuilder.SchedulerTimeZone;
+            
+            // Apply JSON serializer options for ticker requests if configured during service registration
+            if (optionInstance.RequestJsonSerializerOptions != null)
+            {
+                TickerHelper.RequestJsonSerializerOptions = optionInstance.RequestJsonSerializerOptions;
+            }
             services.AddSingleton<ITimeTickerManager<TTimeTicker>, TickerManager<TTimeTicker, TCronTicker>>();
             services.AddSingleton<ICronTickerManager<TCronTicker>, TickerManager<TTimeTicker, TCronTicker>>();
             services.AddSingleton<IInternalTickerManager, InternalTickerManager<TTimeTicker, TCronTicker>>();