@quenty/influxdbclient 7.37.0 → 7.39.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [7.39.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/influxdbclient@7.38.0...@quenty/influxdbclient@7.39.0) (2026-07-22)
+
+### Features
+
+- Add tests to InfluxDBClient package ([c2b138f](https://github.com/Quenty/NevermoreEngine/commit/c2b138f0c0ed050dd6cb3541f644b766b5db6b10))
+
+# [7.38.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/influxdbclient@7.37.0...@quenty/influxdbclient@7.38.0) (2026-07-21)
+
+**Note:** Version bump only for package @quenty/influxdbclient
+
 # [7.37.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/influxdbclient@7.36.0...@quenty/influxdbclient@7.37.0) (2026-07-18)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/influxdbclient",
-  "version": "7.37.0",
+  "version": "7.39.0",
   "description": "Provides a Roblox Lua InfluxDB client",
   "keywords": [
     "Roblox",
@@ -47,5 +47,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "647acfad93dca41c38f59cda247d2bfc0fff36d4"
+  "gitHead": "93f15b200c0f465a0b5304fcf05f5cfe7fdcbd1d"
 }

package/src/Server/Config/InfluxDBClientConfigUtils.spec.lua

@@ -0,0 +1,86 @@
+--!strict
+--[[
+	@class InfluxDBClientConfigUtils.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBClientConfigUtils = require("InfluxDBClientConfigUtils")
+local Jest = require("Jest")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+describe("InfluxDBClientConfigUtils.isClientConfig", function()
+	it("should be true for a config with a string token", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig({
+			url = "https://us-east-1-1.aws.cloud2.influxdata.com",
+			token = "my-token",
+		})).toEqual(true)
+	end)
+
+	it("should be false for a non-table", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig(nil)).toEqual(false)
+		expect(InfluxDBClientConfigUtils.isClientConfig("str")).toEqual(false)
+		expect(InfluxDBClientConfigUtils.isClientConfig(5)).toEqual(false)
+	end)
+
+	it("should be false when url is missing", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig({
+			token = "my-token",
+		})).toEqual(false)
+	end)
+
+	it("should be false when url is not a string", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig({
+			url = 5,
+			token = "my-token",
+		})).toEqual(false)
+	end)
+
+	it("should be false when token is missing", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig({
+			url = "https://example.com",
+		})).toEqual(false)
+	end)
+
+	it("should be false when token is a number", function()
+		expect(InfluxDBClientConfigUtils.isClientConfig({
+			url = "https://example.com",
+			token = 5,
+		})).toEqual(false)
+	end)
+end)
+
+describe("InfluxDBClientConfigUtils.createClientConfig", function()
+	it("should return a config with only url and token fields", function()
+		local config = InfluxDBClientConfigUtils.createClientConfig({
+			url = "https://example.com",
+			token = "my-token",
+			extra = "ignored",
+		} :: any)
+
+		expect(config.url).toEqual("https://example.com")
+		expect(config.token).toEqual("my-token")
+		expect((config :: any).extra).toEqual(nil)
+	end)
+
+	it("should return a fresh table, not the same reference", function()
+		local input = {
+			url = "https://example.com",
+			token = "my-token",
+		}
+		local config = InfluxDBClientConfigUtils.createClientConfig(input)
+
+		expect(config).never.toBe(input)
+	end)
+
+	it("should throw on an invalid config", function()
+		expect(function()
+			InfluxDBClientConfigUtils.createClientConfig({
+				token = "my-token",
+			} :: any)
+		end).toThrow("Bad config")
+	end)
+end)

package/src/Server/Config/InfluxDBWriteOptionUtils.spec.lua

@@ -0,0 +1,94 @@
+--!strict
+--[[
+	@class InfluxDBWriteOptionUtils.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBWriteOptionUtils = require("InfluxDBWriteOptionUtils")
+local Jest = require("Jest")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+describe("InfluxDBWriteOptionUtils.getDefaultOptions", function()
+	it("should return the documented defaults", function()
+		local options = InfluxDBWriteOptionUtils.getDefaultOptions()
+
+		expect(options.batchSize).toEqual(1000)
+		expect(options.maxBatchBytes).toEqual(50_000_000)
+		expect(options.flushIntervalSeconds).toEqual(60)
+	end)
+
+	it("should return a readonly table", function()
+		local options = InfluxDBWriteOptionUtils.getDefaultOptions()
+
+		expect(function()
+			(options :: any).batchSize = 5
+		end).toThrow()
+	end)
+end)
+
+describe("InfluxDBWriteOptionUtils.isWriteOptions", function()
+	it("should be true for a fully specified options table", function()
+		expect(InfluxDBWriteOptionUtils.isWriteOptions({
+			batchSize = 10,
+			maxBatchBytes = 1000,
+			flushIntervalSeconds = 5,
+		})).toEqual(true)
+	end)
+
+	it("should be false for a non-table", function()
+		expect(InfluxDBWriteOptionUtils.isWriteOptions(nil)).toEqual(false)
+		expect(InfluxDBWriteOptionUtils.isWriteOptions("str")).toEqual(false)
+	end)
+
+	it("should be false when batchSize is missing", function()
+		expect(InfluxDBWriteOptionUtils.isWriteOptions({
+			maxBatchBytes = 1000,
+			flushIntervalSeconds = 5,
+		})).toEqual(false)
+	end)
+
+	it("should be false when maxBatchBytes is not a number", function()
+		expect(InfluxDBWriteOptionUtils.isWriteOptions({
+			batchSize = 10,
+			maxBatchBytes = "1000",
+			flushIntervalSeconds = 5,
+		})).toEqual(false)
+	end)
+
+	it("should be false when flushIntervalSeconds is missing", function()
+		expect(InfluxDBWriteOptionUtils.isWriteOptions({
+			batchSize = 10,
+			maxBatchBytes = 1000,
+		})).toEqual(false)
+	end)
+end)
+
+describe("InfluxDBWriteOptionUtils.createWriteOptions", function()
+	it("should return a readonly copy of valid options", function()
+		local options = InfluxDBWriteOptionUtils.createWriteOptions({
+			batchSize = 10,
+			maxBatchBytes = 1000,
+			flushIntervalSeconds = 5,
+		})
+
+		expect(options.batchSize).toEqual(10)
+		expect(options.maxBatchBytes).toEqual(1000)
+		expect(options.flushIntervalSeconds).toEqual(5)
+
+		expect(function()
+			(options :: any).batchSize = 20
+		end).toThrow()
+	end)
+
+	it("should throw on invalid options", function()
+		expect(function()
+			InfluxDBWriteOptionUtils.createWriteOptions({
+				batchSize = 10,
+			} :: any)
+		end).toThrow("Bad options")
+	end)
+end)

package/src/Server/InfluxDBClient.lua

@@ -10,6 +10,7 @@ local require = require(script.Parent.loader).load(script)
 
 local BaseObject = require("BaseObject")
 local InfluxDBClientConfigUtils = require("InfluxDBClientConfigUtils")
+local InfluxDBRequestHandlerMock = require("InfluxDBRequestHandlerMock")
 local InfluxDBWriteAPI = require("InfluxDBWriteAPI")
 local Maid = require("Maid")
 local Promise = require("Promise")
@@ -26,6 +27,7 @@ export type InfluxDBClient =
 			_clientConfig: ValueObject.ValueObject<InfluxDBClientConfigUtils.InfluxDBClientConfig>,
 			_writeApis: { [string]: { [string]: InfluxDBWriteAPI.InfluxDBWriteAPI } },
 			_flushAllPromises: Promise.Promise<()>,
+			_requestHandler: InfluxDBWriteAPI.InfluxDBRequestHandler?,
 		},
 		{} :: typeof({ __index = InfluxDBClient })
 	))
@@ -35,11 +37,20 @@ export type InfluxDBClient =
 	Creates a new InfluxDB client
 
 	@param clientConfig InfluxDBClientConfig?
+	@param requestHandler InfluxDBRequestHandler? -- Defaults to [HttpPromise.request]. Inject a mock to avoid real HTTP.
 	@return InfluxDBClient
 ]=]
-function InfluxDBClient.new(clientConfig: InfluxDBClientConfigUtils.InfluxDBClientConfig?): InfluxDBClient
+function InfluxDBClient.new(
+	clientConfig: InfluxDBClientConfigUtils.InfluxDBClientConfig?,
+	requestHandler: InfluxDBWriteAPI.InfluxDBRequestHandler?
+): InfluxDBClient
 	local self: InfluxDBClient = setmetatable(BaseObject.new() :: any, InfluxDBClient)
 
+	assert(type(requestHandler) == "function" or requestHandler == nil, "Bad requestHandler")
+
+	-- Threaded down into each write API created by GetWriteAPI so all of them share the same seam.
+	self._requestHandler = requestHandler
+
 	self._clientConfig = self._maid:Add(ValueObject.new(nil))
 
 	if clientConfig then
@@ -51,6 +62,33 @@ function InfluxDBClient.new(clientConfig: InfluxDBClientConfigUtils.InfluxDBClie
 	return self
 end
 
+--[=[
+	Creates a new InfluxDB client wired to an [InfluxDBRequestHandlerMock] so no real HTTP calls are
+	made. Returns both the client and the mock, so a test can inspect the requests it would have sent.
+
+	```lua
+	local client, requestMock = InfluxDBClient.newMock()
+	client:SetClientConfig({ url = "https://example.com", token = "token" })
+
+	local writeAPI = client:GetWriteAPI("org", "bucket")
+	writeAPI:QueuePoint(point)
+	writeAPI:PromiseFlush():Wait()
+
+	print(#requestMock:GetRequests()) --> 1
+	```
+
+	@param clientConfig InfluxDBClientConfig?
+	@return (InfluxDBClient, InfluxDBRequestHandlerMock)
+]=]
+function InfluxDBClient.newMock(
+	clientConfig: InfluxDBClientConfigUtils.InfluxDBClientConfig?
+): (InfluxDBClient, InfluxDBRequestHandlerMock.InfluxDBRequestHandlerMock)
+	local requestMock = InfluxDBRequestHandlerMock.new()
+	local client = InfluxDBClient.new(clientConfig, requestMock.Handler)
+
+	return client, requestMock
+end
+
 --[=[
 	Sets the client config for this client
 
@@ -83,10 +121,14 @@ function InfluxDBClient.GetWriteAPI(
 
 	local maid = Maid.new()
 
-	local writeAPI = maid:Add(InfluxDBWriteAPI.new(org, bucket, precision))
+	local writeAPI = maid:Add(InfluxDBWriteAPI.new(org, bucket, precision, self._requestHandler))
 
 	maid:GiveTask(self._clientConfig:Observe():Subscribe(function(clientConfig)
-		writeAPI:SetClientConfig(clientConfig)
+		-- The observable fires the current value immediately, which is nil until a config is set. Guard
+		-- so GetWriteAPI can be called before SetClientConfig; the later config is pushed through here.
+		if clientConfig then
+			writeAPI:SetClientConfig(clientConfig)
+		end
 	end))
 
 	maid:GiveTask(writeAPI.Destroying:Connect(function()

package/src/Server/InfluxDBClient.spec.lua

@@ -0,0 +1,227 @@
+--!strict
+--[[
+	@class InfluxDBClient.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBClient = require("InfluxDBClient")
+local InfluxDBPoint = require("InfluxDBPoint")
+local InfluxDBRequestHandlerMock = require("InfluxDBRequestHandlerMock")
+local Jest = require("Jest")
+local Promise = require("Promise")
+local PromiseTestUtils = require("PromiseTestUtils")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+local FIXED_TIMESTAMP = DateTime.fromUnixTimestampMillis(1600000000000)
+
+local CONFIG = {
+	url = "https://example.com",
+	token = "my-token",
+}
+
+local function newPoint(): InfluxDBPoint.InfluxDBPoint
+	local point = InfluxDBPoint.new("temperature")
+	point:SetTimestamp(FIXED_TIMESTAMP)
+	point:AddFloatField("value", 23.5)
+	return point
+end
+
+describe("InfluxDBClient.new", function()
+	it("should construct without a config", function()
+		local client = InfluxDBClient.new()
+		expect(client.ClassName).toEqual("InfluxDBClient")
+		client:Destroy()
+	end)
+
+	it("should construct with a config", function()
+		local client = InfluxDBClient.new(CONFIG)
+		expect(client.ClassName).toEqual("InfluxDBClient")
+		client:Destroy()
+	end)
+
+	it("should throw when constructed with an invalid config", function()
+		expect(function()
+			InfluxDBClient.new({ url = "https://example.com" } :: any)
+		end).toThrow("Bad clientConfig")
+	end)
+
+	it("should throw on a non-function, non-nil request handler", function()
+		expect(function()
+			InfluxDBClient.new(nil, 5 :: any)
+		end).toThrow("Bad requestHandler")
+	end)
+end)
+
+describe("InfluxDBClient.newMock", function()
+	it("should return a client and a request handler mock", function()
+		local client, requestMock = InfluxDBClient.newMock()
+
+		expect(client.ClassName).toEqual("InfluxDBClient")
+		expect(InfluxDBRequestHandlerMock.isInfluxDBRequestHandlerMock(requestMock)).toEqual(true)
+
+		client:Destroy()
+	end)
+
+	it("should route write API traffic through the mock instead of the network", function()
+		local client, requestMock = InfluxDBClient.newMock(CONFIG)
+
+		local writeAPI = client:GetWriteAPI("my-org", "my-bucket")
+		writeAPI:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(writeAPI:PromiseFlush())).toEqual(true)
+
+		expect(#requestMock:GetRequests()).toEqual(1)
+		expect((requestMock:GetLastRequest() :: any).Headers.Authorization).toEqual("Token my-token")
+
+		client:Destroy()
+	end)
+end)
+
+describe("InfluxDBClient.SetClientConfig", function()
+	it("should throw on an invalid config", function()
+		local client = InfluxDBClient.new()
+
+		expect(function()
+			client:SetClientConfig({ token = "my-token" } :: any)
+		end).toThrow("Bad clientConfig")
+
+		client:Destroy()
+	end)
+end)
+
+describe("InfluxDBClient.GetWriteAPI", function()
+	it("should throw on a non-string org", function()
+		local client = InfluxDBClient.new()
+		expect(function()
+			client:GetWriteAPI(5 :: any, "my-bucket")
+		end).toThrow("Bad org")
+		client:Destroy()
+	end)
+
+	it("should throw on a non-string bucket", function()
+		local client = InfluxDBClient.new()
+		expect(function()
+			client:GetWriteAPI("my-org", 5 :: any)
+		end).toThrow("Bad bucket")
+		client:Destroy()
+	end)
+
+	it("should throw on a non-string, non-nil precision", function()
+		local client = InfluxDBClient.new()
+		expect(function()
+			client:GetWriteAPI("my-org", "my-bucket", 5 :: any)
+		end).toThrow("Bad precision")
+		client:Destroy()
+	end)
+
+	-- Regression: GetWriteAPI must work before a config is set. Its ValueObject:Observe() subscription
+	-- fires the current value (nil) immediately; without a nil guard in GetWriteAPI this would call
+	-- writeAPI:SetClientConfig(nil) and throw "Bad clientConfig".
+	it("should return a write API", function()
+		local client = InfluxDBClient.new()
+		local writeAPI = client:GetWriteAPI("my-org", "my-bucket")
+		expect(writeAPI.ClassName).toEqual("InfluxDBWriteAPI")
+		client:Destroy()
+	end)
+
+	it("should return the same write API for the same org and bucket", function()
+		local client = InfluxDBClient.new()
+		local first = client:GetWriteAPI("my-org", "my-bucket")
+		local second = client:GetWriteAPI("my-org", "my-bucket")
+		expect(second).toBe(first)
+		client:Destroy()
+	end)
+
+	it("should return a different write API for a different bucket", function()
+		local client = InfluxDBClient.new()
+		local first = client:GetWriteAPI("my-org", "bucket-a")
+		local second = client:GetWriteAPI("my-org", "bucket-b")
+		expect(second).never.toBe(first)
+		client:Destroy()
+	end)
+
+	it("should return a different write API for a different org", function()
+		local client = InfluxDBClient.new()
+		local first = client:GetWriteAPI("org-a", "my-bucket")
+		local second = client:GetWriteAPI("org-b", "my-bucket")
+		expect(second).never.toBe(first)
+		client:Destroy()
+	end)
+
+	it("should propagate the client config set before GetWriteAPI to the write API", function()
+		local client, requestMock = InfluxDBClient.newMock(CONFIG)
+		local writeAPI = client:GetWriteAPI("my-org", "my-bucket")
+
+		-- If the config had not reached the write API, the flush would reject with "No client configuration".
+		writeAPI:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(writeAPI:PromiseFlush())).toEqual(true)
+
+		expect(#requestMock:GetRequests()).toEqual(1)
+
+		client:Destroy()
+	end)
+
+	it("should propagate a client config set after GetWriteAPI to the write API", function()
+		local client, requestMock = InfluxDBClient.newMock()
+		local writeAPI = client:GetWriteAPI("my-org", "my-bucket")
+
+		client:SetClientConfig(CONFIG)
+
+		writeAPI:QueuePoint(newPoint())
+		expect(PromiseTestUtils.awaitSettled(writeAPI:PromiseFlush())).toEqual(true)
+
+		expect(#requestMock:GetRequests()).toEqual(1)
+
+		client:Destroy()
+	end)
+end)
+
+describe("InfluxDBClient.PromiseFlushAll", function()
+	it("should resolve when there are no write APIs", function()
+		local client = InfluxDBClient.new()
+
+		expect(PromiseTestUtils.awaitSettled(client:PromiseFlushAll())).toEqual(true)
+
+		client:Destroy()
+	end)
+
+	it("should flush buffered points across every write API", function()
+		local client, requestMock = InfluxDBClient.newMock(CONFIG)
+
+		local apiA = client:GetWriteAPI("my-org", "bucket-a")
+		local apiB = client:GetWriteAPI("my-org", "bucket-b")
+		apiA:QueuePoint(newPoint())
+		apiB:QueuePoint(newPoint())
+
+		expect(PromiseTestUtils.awaitSettled(client:PromiseFlushAll())).toEqual(true)
+		expect(#requestMock:GetRequests()).toEqual(2)
+
+		client:Destroy()
+	end)
+
+	it("should reuse the pending flush promise while one is in flight", function()
+		local client, requestMock = InfluxDBClient.newMock(CONFIG)
+
+		-- A request that never settles keeps the flush pending, so both calls observe the same promise.
+		requestMock:SetResponder(function()
+			return Promise.new(function() end)
+		end)
+
+		local writeAPI = client:GetWriteAPI("my-org", "my-bucket")
+		writeAPI:QueuePoint(newPoint())
+
+		local first = client:PromiseFlushAll()
+		local second = client:PromiseFlushAll()
+
+		expect(second).toBe(first)
+
+		-- Destroy cancels the in-flight request, rejecting this promise; consume it so the cancellation
+		-- does not surface as an unhandled rejection.
+		first:Catch(function() end)
+
+		client:Destroy()
+	end)
+end)

package/src/Server/InfluxDBService.lua

@@ -0,0 +1,147 @@
+--!strict
+--[=[
+	Centralized service using serviceBag. Lets other packages share a single [InfluxDBClient] and, in
+	tests, swap the underlying request implementation for an [InfluxDBRequestHandlerMock] at the
+	ServiceBag layer -- the same pattern as [PlayerDataStoreService.SetRobloxDataStore].
+
+	```lua
+	-- Production
+	local influxDBService = serviceBag:GetService(require("InfluxDBService"))
+	-- ...after Init, before first use...
+	influxDBService:SetClientConfig({ url = "https://example.com", token = "token" })
+
+	local writeAPI = influxDBService:GetWriteAPI("org", "bucket")
+	writeAPI:QueuePoint(point)
+	```
+
+	```lua
+	-- Tests: inject a mock so nothing hits the network
+	local requestMock = InfluxDBRequestHandlerMock.new()
+	influxDBService:SetRequestHandler(requestMock.Handler)
+	```
+
+	@server
+	@class InfluxDBService
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBClient = require("InfluxDBClient")
+local InfluxDBClientConfigUtils = require("InfluxDBClientConfigUtils")
+local InfluxDBWriteAPI = require("InfluxDBWriteAPI")
+local Maid = require("Maid")
+local Promise = require("Promise")
+local ServiceBag = require("ServiceBag")
+
+local InfluxDBService = {}
+InfluxDBService.ServiceName = "InfluxDBService"
+
+export type InfluxDBService = typeof(setmetatable(
+	{} :: {
+		_serviceBag: ServiceBag.ServiceBag,
+		_maid: Maid.Maid,
+		_client: InfluxDBClient.InfluxDBClient?,
+		_requestHandler: InfluxDBWriteAPI.InfluxDBRequestHandler?,
+		_pendingClientConfig: InfluxDBClientConfigUtils.InfluxDBClientConfig?,
+	},
+	{} :: typeof({ __index = InfluxDBService })
+))
+
+--[=[
+	Initializes the InfluxDBService. Should be done via [ServiceBag.Init].
+
+	@param serviceBag ServiceBag
+]=]
+function InfluxDBService.Init(self: InfluxDBService, serviceBag: ServiceBag.ServiceBag): ()
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._maid = Maid.new()
+end
+
+--[=[
+	Injects the request handler the underlying client uses to send data, instead of the real
+	[HttpPromise.request]. Pass an [InfluxDBRequestHandlerMock] handler so tests never hit the network.
+	Intended for testing; must be called before the client is first built.
+
+	@param requestHandler InfluxDBRequestHandler
+]=]
+function InfluxDBService.SetRequestHandler(
+	self: InfluxDBService,
+	requestHandler: InfluxDBWriteAPI.InfluxDBRequestHandler
+): ()
+	assert(type(requestHandler) == "function", "Bad requestHandler")
+	assert(not self._client, "Already built client, cannot override requestHandler")
+
+	self._requestHandler = requestHandler
+end
+
+--[=[
+	Sets the client config used to authenticate writes. May be called before or after the client is
+	built; a later config is forwarded to the existing client.
+
+	@param clientConfig InfluxDBClientConfig
+]=]
+function InfluxDBService.SetClientConfig(
+	self: InfluxDBService,
+	clientConfig: InfluxDBClientConfigUtils.InfluxDBClientConfig
+): ()
+	assert(InfluxDBClientConfigUtils.isClientConfig(clientConfig), "Bad clientConfig")
+
+	self._pendingClientConfig = clientConfig
+
+	if self._client then
+		self._client:SetClientConfig(clientConfig)
+	end
+end
+
+--[=[
+	Returns the shared [InfluxDBClient], building it on first use with any injected request handler and
+	client config.
+
+	@return InfluxDBClient
+]=]
+function InfluxDBService.GetClient(self: InfluxDBService): InfluxDBClient.InfluxDBClient
+	if self._client then
+		return self._client
+	end
+
+	local client = self._maid:Add(InfluxDBClient.new(self._pendingClientConfig, self._requestHandler))
+	self._client = client
+
+	return client
+end
+
+--[=[
+	Returns the write API for the given org and bucket from the shared client.
+
+	@param org string
+	@param bucket string
+	@param precision string?
+	@return InfluxDBWriteAPI
+]=]
+function InfluxDBService.GetWriteAPI(
+	self: InfluxDBService,
+	org: string,
+	bucket: string,
+	precision: string?
+): InfluxDBWriteAPI.InfluxDBWriteAPI
+	return self:GetClient():GetWriteAPI(org, bucket, precision)
+end
+
+--[=[
+	Flushes every write API on the shared client. Resolves immediately if the client was never built.
+
+	@return Promise<()>
+]=]
+function InfluxDBService.PromiseFlushAll(self: InfluxDBService): Promise.Promise<()>
+	if not self._client then
+		return Promise.resolved()
+	end
+
+	return self._client:PromiseFlushAll()
+end
+
+function InfluxDBService.Destroy(self: InfluxDBService): ()
+	self._maid:DoCleaning()
+end
+
+return InfluxDBService