# Influx Db

## Description

InfluxDB can be used as the backing implementation for Flex time-series operations. Your application code should depend on `IFlexTimeSeriesStore`, while Flex provides the provider bridge and wiring.

## Important concepts

* **`IFlexTimeSeriesStore` is the contract**: app code writes and queries time-series data via a shared interface.
* **Bucket-based storage**: InfluxDB typically stores points into a bucket (configured in appsettings).
* **Provider bridge**: the InfluxDB implementation is exposed via an `IFlexTimeSeriesStoreBridge` internally, but most consumers only need `IFlexTimeSeriesStore`.

## Configuration in DI

Add the provider in your DI composition root (commonly in `EndPoints/...CommonConfigs/OtherApplicationServicesConfig.cs` or wherever you centralize registrations).

```csharp
// using Sumeru.Flex; // IFlexTimeSeriesStore

public static class OtherApplicationServicesConfig
{
	public static IServiceCollection AddOtherApplicationServices(
		this IServiceCollection services,
		IConfiguration configuration)
	{
		// Registers InfluxDB as the IFlexTimeSeriesStore bridge.
		// Flex auto-wires generated Queries/Handlers that *use* IFlexTimeSeriesStore.
		services.AddFlexInfluxDBTimeSeriesStore(configuration);

		return services;
	}
}
```

## appsettings.json

Configuration is read from `FlexBase:DataStores:TimeSeries:InfluxDB`.

```json
{
  "FlexBase": {
	"DataStores": {
	  "TimeSeries": {
		"InfluxDB": {
		  "Url": "http://localhost:8086",
		  "Token": "...",
		  "Organization": "your-org",
		  "Bucket": "your-bucket"
		}
	  }
	}
  }
}
```

## Examples (template-based)

These examples mirror the generated Query and PostBusHandler templates. You do **not** register these types manually—Flex discovers and wires generated Queries/Handlers automatically.

### Get points in a time range (Query)

```csharp
using Microsoft.Extensions.Logging;
using Sumeru.Flex;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace {YourApplication}.Queries.TimeSeries;

public class TelemetryGetRange : FlexiQueryEnumerableBridgeAsync<TelemetryPointDto>
{
	protected readonly ILogger<TelemetryGetRange> _logger;
	protected readonly IFlexHost _flexHost;
	protected readonly IFlexTimeSeriesStore _timeSeriesStore;
	protected TelemetryGetRangeParams _params;
	protected FlexAppContextBridge _flexAppContext;

	public TelemetryGetRange(ILogger<TelemetryGetRange> logger, IFlexHost flexHost, IFlexTimeSeriesStore timeSeriesStore)
	{
		_logger = logger;
		_flexHost = flexHost;
		_timeSeriesStore = timeSeriesStore;
	}

	public virtual TelemetryGetRange AssignParameters(TelemetryGetRangeParams @params)
	{
		_params = @params;
		return this;
	}

	public virtual async Task<IEnumerable<TelemetryPointDto>> Fetch()
	{
		_flexAppContext = _params.GetAppContext();
		var points = await _timeSeriesStore.QueryAsync<TelemetryPoint>(_params.SeriesId, _params.StartTime, _params.EndTime);
		// TODO: map TelemetryPoint -> TelemetryPointDto
		return points as IEnumerable<TelemetryPointDto>;
	}
}

public class TelemetryGetRangeParams : DtoBridge
{
	public string SeriesId { get; set; }
	public DateTime StartTime { get; set; }
	public DateTime EndTime { get; set; }
}
```

## InfluxDB considerations

* Keep `Token` in a secrets provider (don’t commit it to source control).
* Ensure `Bucket` exists and the token has access to read/write it.