native adapters

SW.Bitween.Api/Resources/Adapters/GetProperties.cs

@@ -12,15 +12,26 @@ namespace SW.Bitween.Resources.Adapters
     public class GetProperties : IGetHandler<string,object>
     {
         private readonly IServerlessService serverless;
+        private readonly NativeAdapterDiscoveryService _nativeAdapterDiscovery;
 
-        public GetProperties(IServerlessService serverless)
+        public GetProperties(IServerlessService serverless, NativeAdapterDiscoveryService nativeAdapterDiscovery)
         {
             this.serverless = serverless;
+            _nativeAdapterDiscovery = nativeAdapterDiscovery;
         }
 
         async public Task<object> Handle(string key)
         {
-            await serverless.StartAsync( Uri.UnescapeDataString(key), null);
+            var decodedKey = Uri.UnescapeDataString(key);
+
+            // Check if it's a native adapter
+            if (decodedKey.StartsWith("native.", StringComparison.OrdinalIgnoreCase))
+            {
+                return _nativeAdapterDiscovery.GetNativeAdapterProperties(decodedKey);
+            }
+
+            // Handle serverless adapters
+            await serverless.StartAsync(decodedKey, null);
             var expected = await serverless.GetExpectedStartupValues();
             return expected.ToList().ToDictionary(k => k.Key, v => $"{v.Key} {(v.Value.Optional ? $" ({v.Value.Default ?? "null"})" : " *")}");
         }

SW.Bitween.Api/Resources/Adapters/Search.cs

@@ -10,17 +10,23 @@ public class Search : IQueryHandler<AdapterSearchRequest,object>
     {
         private readonly ServerlessOptions _serverlessOptions;
         private readonly ICloudFilesService _cloudFilesService;
+        private readonly NativeAdapterDiscoveryService _nativeAdapterDiscovery;
 
-        public Search(ServerlessOptions serverlessOptions, ICloudFilesService cloudFilesService)
+        public Search(ServerlessOptions serverlessOptions, ICloudFilesService cloudFilesService,
+            NativeAdapterDiscoveryService nativeAdapterDiscovery)
         {
             _serverlessOptions = serverlessOptions;
             _cloudFilesService = cloudFilesService;
+            _nativeAdapterDiscovery = nativeAdapterDiscovery;
         }
 
 
         public async Task<object> Handle(AdapterSearchRequest request)
         {
+            // Get native adapters first
+            var nativeAdapters = _nativeAdapterDiscovery.GetNativeAdapters(request.Prefix).ToList();
 
+            // Get external adapters from storage
             var cloudFilesList =
                 (await _cloudFilesService.ListAsync(
                     $"{_serverlessOptions.AdapterRemotePath}/infolink6.{request.Prefix}"))
@@ -33,10 +39,13 @@ public async Task<object> Handle(AdapterSearchRequest request)
 
                     return key;
                 })
+                .Distinct()
                 .ToList();
 
+            // Combine native (first) and external adapters
+            var allAdapters = nativeAdapters.Concat(cloudFilesList);
 
-            return cloudFilesList.Distinct().ToDictionary(k => k, v => v);
+            return allAdapters.ToDictionary(k => k, v => v);
         }
     }
 }

SW.Bitween.Api/Resources/Adapters/SearchVersioned.cs

@@ -12,18 +12,31 @@ public class SearchVersioned : IQueryHandler<AdapterSearchRequest,object>
     {
         private readonly ServerlessOptions _serverlessOptions;
         private readonly ICloudFilesService _cloudFilesService;
+        private readonly NativeAdapterDiscoveryService _nativeAdapterDiscovery;
 
-        public SearchVersioned(ServerlessOptions serverlessOptions, ICloudFilesService cloudFilesService)
+        public SearchVersioned(ServerlessOptions serverlessOptions, ICloudFilesService cloudFilesService,
+            NativeAdapterDiscoveryService nativeAdapterDiscovery)
         {
             _serverlessOptions = serverlessOptions;
             _cloudFilesService = cloudFilesService;
+            _nativeAdapterDiscovery = nativeAdapterDiscovery;
         }
 
 
         public async Task<object> Handle(AdapterSearchRequest request)
         {
             var index = _serverlessOptions.AdapterRemotePath.Length + 1;
 
+            // Get native adapters first (they don't have versions)
+            var nativeAdapters = _nativeAdapterDiscovery.GetNativeAdapters(request.Prefix)
+                .Select(key => new
+                {
+                    Key = key,
+                    Versions = new List<object>() // Native adapters have no versions
+                })
+                .ToList();
+
+            // Get external adapters from storage
             var cloudFilesList =
                 (await _cloudFilesService.ListAsync(
                     $"{_serverlessOptions.AdapterRemotePath}/infolink6.{request.Prefix}"))
@@ -40,7 +53,7 @@ public async Task<object> Handle(AdapterSearchRequest request)
                     return key;
                 });
 
-            return grouped.Select(i => new
+            var externalAdapters = grouped.Select(i => new
             {
                 i.Key,
                 Versions = i.Where(v => v.Key != i.Key && Semver.IsVersionNumber(v.Key.Split("/").Last()))
@@ -49,6 +62,9 @@ public async Task<object> Handle(AdapterSearchRequest request)
                         Key = v.Key[index..]
                     }).ToList()
             });
+
+            // Return native adapters first, then external
+            return nativeAdapters.Concat<object>(externalAdapters);
         }
     }
 }

SW.Bitween.Api/Resources/Subscriptions/Update.cs

@@ -102,10 +102,24 @@ public Validate(IServiceProvider serviceProvider)
                 {
                     RuleFor(i => i.MapperProperties).CustomAsync(async (i, context, ct) =>
                     {
-                        var serverless = serviceProvider.GetService<IServerlessService>();
-                        await serverless.StartAsync(((SubscriptionUpdate)context.InstanceToValidate).MapperId, null);
-                        var mustProps = (await serverless.GetExpectedStartupValues())
-                            .Where(p => p.Value.Optional == false).Select(p => p.Key);
+                        var mapperId = ((SubscriptionUpdate)context.InstanceToValidate).MapperId;
+                        var mustProps = Enumerable.Empty<string>();
+
+                        // Check if it's a native adapter
+                        if (mapperId.StartsWith("native.", StringComparison.OrdinalIgnoreCase))
+                        {
+                            var nativeAdapterDiscovery = serviceProvider.GetService<NativeAdapterDiscoveryService>();
+                            var properties = nativeAdapterDiscovery.GetNativeAdapterProperties(mapperId);
+                            mustProps = properties.Where(p => p.Value.EndsWith(" *")).Select(p => p.Key);
+                        }
+                        else
+                        {
+                            var serverless = serviceProvider.GetService<IServerlessService>();
+                            await serverless.StartAsync(mapperId, null);
+                            mustProps = (await serverless.GetExpectedStartupValues())
+                                .Where(p => p.Value.Optional == false).Select(p => p.Key);
+                        }
+
                         var missing = mustProps.ToHashSet(StringComparer.OrdinalIgnoreCase)
                             .Except(i.Where(p => !string.IsNullOrEmpty(p.Value)).Select(p => p.Key));
                         if (missing.Any())
@@ -117,10 +131,24 @@ public Validate(IServiceProvider serviceProvider)
                 {
                     RuleFor(i => i.HandlerProperties).CustomAsync(async (i, context, ct) =>
                     {
-                        var serverless = serviceProvider.GetService<IServerlessService>();
-                        await serverless.StartAsync(((SubscriptionUpdate)context.InstanceToValidate).HandlerId, null);
-                        var mustProps = (await serverless.GetExpectedStartupValues())
-                            .Where(p => p.Value.Optional == false).Select(p => p.Key);
+                        var handlerId = ((SubscriptionUpdate)context.InstanceToValidate).HandlerId;
+                        var mustProps = Enumerable.Empty<string>();
+
+                        // Check if it's a native adapter
+                        if (handlerId.StartsWith("native.", StringComparison.OrdinalIgnoreCase))
+                        {
+                            var nativeAdapterDiscovery = serviceProvider.GetService<NativeAdapterDiscoveryService>();
+                            var properties = nativeAdapterDiscovery.GetNativeAdapterProperties(handlerId);
+                            mustProps = properties.Where(p => p.Value.EndsWith(" *")).Select(p => p.Key);
+                        }
+                        else
+                        {
+                            var serverless = serviceProvider.GetService<IServerlessService>();
+                            await serverless.StartAsync(handlerId, null);
+                            mustProps = (await serverless.GetExpectedStartupValues())
+                                .Where(p => p.Value.Optional == false).Select(p => p.Key);
+                        }
+
                         var missing = mustProps.ToHashSet(StringComparer.OrdinalIgnoreCase)
                             .Except(i.Where(p => !string.IsNullOrEmpty(p.Value)).Select(p => p.Key));
                         if (missing.Any())
@@ -137,11 +165,24 @@ public Validate(IServiceProvider serviceProvider)
                     {
                         RuleFor(i => i.ReceiverProperties).CustomAsync(async (i, context, ct) =>
                         {
-                            var serverless = serviceProvider.GetService<IServerlessService>();
-                            await serverless.StartAsync(((SubscriptionUpdate)context.InstanceToValidate).ReceiverId,
-                                null);
-                            var mustProps = (await serverless.GetExpectedStartupValues())
-                                .Where(p => p.Value.Optional == false).Select(p => p.Key);
+                            var receiverId = ((SubscriptionUpdate)context.InstanceToValidate).ReceiverId;
+                            var mustProps = Enumerable.Empty<string>();
+
+                            // Check if it's a native adapter
+                            if (receiverId.StartsWith("native.", StringComparison.OrdinalIgnoreCase))
+                            {
+                                var nativeAdapterDiscovery = serviceProvider.GetService<NativeAdapterDiscoveryService>();
+                                var properties = nativeAdapterDiscovery.GetNativeAdapterProperties(receiverId);
+                                mustProps = properties.Where(p => p.Value.EndsWith(" *")).Select(p => p.Key);
+                            }
+                            else
+                            {
+                                var serverless = serviceProvider.GetService<IServerlessService>();
+                                await serverless.StartAsync(receiverId, null);
+                                mustProps = (await serverless.GetExpectedStartupValues())
+                                    .Where(p => p.Value.Optional == false).Select(p => p.Key);
+                            }
+
                             var missing = mustProps.ToHashSet(StringComparer.OrdinalIgnoreCase)
                                 .Except(i.Where(p => !string.IsNullOrEmpty(p.Value)).Select(p => p.Key));
                             if (missing.Any())

SW.Bitween.Api/SW.Bitween.Api.csproj

@@ -27,6 +27,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\SW.Bitween.NativeAdapters\SW.Bitween.NativeAdapters.csproj" />
     <ProjectReference Include="..\SW.Bitween.Sdk\SW.Bitween.Sdk.csproj" />
   </ItemGroup>
 

SW.Bitween.Api/Services/NativeAdapterDiscoveryService.cs

@@ -0,0 +1,172 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using SW.Bitween.NativeAdapters;
+using SW.PrimitiveTypes;
+
+namespace SW.Bitween
+{
+    public class NativeAdapterDiscoveryService
+    {
+        private readonly Dictionary<string, List<NativeAdapterInfo>> _adaptersCache;
+
+        public NativeAdapterDiscoveryService()
+        {
+            _adaptersCache = new Dictionary<string, List<NativeAdapterInfo>>();
+            DiscoverNativeAdapters();
+        }
+
+        private void DiscoverNativeAdapters()
+        {
+            var assemblies = new List<Assembly>() { typeof(DictionaryConverter).Assembly };
+
+
+
+        foreach (var assembly in assemblies)
+            {
+                try
+                {
+                    var types = assembly.GetTypes()
+                        .Where(t => t.IsClass && !t.IsAbstract);
+
+                    foreach (var type in types)
+                    {
+                        if (typeof(IInfolinkHandler).IsAssignableFrom(type))
+                        {
+                            AddAdapter("handlers", type);
+                        }
+                        else if (typeof(IInfolinkValidator).IsAssignableFrom(type))
+                        {
+                            AddAdapter("validators", type);
+                        }
+                        else if (typeof(IInfolinkReceiver).IsAssignableFrom(type))
+                        {
+                            AddAdapter("receivers", type);
+                        }
+                    }
+                }
+                catch
+                {
+                    // Skip assemblies that can't be loaded or scanned
+                }
+            }
+        }
+
+        private void AddAdapter(string category, Type type)
+        {
+            if (!_adaptersCache.ContainsKey(category))
+            {
+                _adaptersCache[category] = new List<NativeAdapterInfo>();
+            }
+
+            var adapterName = type.Name;//.Replace("Handler", "").Replace("Mapper", "")
+                //.Replace("Validator", "").Replace("Receiver", "").ToLower();
+
+            _adaptersCache[category].Add(new NativeAdapterInfo
+            {
+                Key = $"native.{adapterName}",
+                Name = type.Name,
+                Type = type,
+                Category = category
+            });
+        }
+
+        public IEnumerable<string> GetNativeAdapters(string prefix)
+        {
+            if (string.IsNullOrEmpty(prefix))
+            {
+                return _adaptersCache.Values.SelectMany(v => v).Select(a => a.Key);
+            }
+
+            var category = prefix.ToLower().TrimStart('.');
+
+            if (_adaptersCache.TryGetValue(category, out var adapters))
+            {
+                return adapters.Select(a => a.Key);
+            }
+
+            return Enumerable.Empty<string>();
+        }
+
+        public NativeAdapterInfo GetNativeAdapterInfo(string adapterId)
+        {
+            return _adaptersCache.Values
+                .SelectMany(v => v)
+                .FirstOrDefault(a => a.Key.Equals(adapterId, StringComparison.OrdinalIgnoreCase));
+        }
+
+        public Dictionary<string, string> GetNativeAdapterProperties(string adapterId)
+        {
+            var adapterInfo = GetNativeAdapterInfo(adapterId);
+            if (adapterInfo == null)
+                return new Dictionary<string, string>();
+
+            var result = new Dictionary<string, string>();
+
+            // Get constructor parameters
+            var constructor = adapterInfo.Type.GetConstructors()
+                .FirstOrDefault(c => c.GetParameters().Length > 0);
+
+            if (constructor == null)
+                return result;
+
+            // Get the first parameter type (input model)
+            var inputParameter = constructor.GetParameters().FirstOrDefault();
+            if (inputParameter == null)
+                return result;
+
+            var inputType = inputParameter.ParameterType;
+
+            // Get all properties from the input model
+            var properties = inputType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+
+            foreach (var prop in properties)
+            {
+                var defaultValue = GetDefaultValue(prop);
+                var hasRequiredAttribute = prop.GetCustomAttribute<System.ComponentModel.DataAnnotations.RequiredAttribute>() != null;
+                var isRequired = hasRequiredAttribute || (!IsNullableType(prop.PropertyType) && defaultValue == null);
+
+                if (isRequired)
+                {
+                    result[prop.Name] = $"{prop.Name} *";
+                }
+                else
+                {
+                    result[prop.Name] = $"{prop.Name} ({defaultValue ?? "null"})";
+                }
+            }
+
+            return result;
+        }
+
+        private string? GetDefaultValue(PropertyInfo property)
+        {
+            // Try to get default value from DefaultValueAttribute if it exists
+            var defaultAttr = property.GetCustomAttribute<System.ComponentModel.DefaultValueAttribute>();
+            if (defaultAttr != null)
+                return defaultAttr.Value?.ToString();
+
+            // For value types, return their default
+            if (property.PropertyType.IsValueType)
+                return Activator.CreateInstance(property.PropertyType)?.ToString();
+
+            return null;
+        }
+
+        private bool IsNullableType(Type type)
+        {
+            return !type.IsValueType || 
+                   Nullable.GetUnderlyingType(type) != null ||
+                   (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>));
+        }
+    }
+
+    public class NativeAdapterInfo
+    {
+        public string Key { get; set; } = string.Empty;
+        public string Name { get; set; } = string.Empty;
+        public Type Type { get; set; } = null!;
+        public string Category { get; set; } = string.Empty;
+    }
+}