Store

This item only works when running on the server. Server

A store is a class that holds inner savable objects, Keep(s), from a datastore DataStoreService:GetDataStore()

Types

StoreInfo

</>

type StoreInfo = {

Name: string,

Scope: string?

}

Table format for a store's info in .GetStore()

unreleasedHandler

</>

type unreleasedHandler = (Session) → string

Used to determine how to handle an session locked Keep.

info

Check LoadMethods for more info.

StoreBase

</>

type StoreBase = {

LoadKeep: (

string,

unreleasedHandler?

) → Promise<Keep>,

ViewKeep: (string) → Promise<Keep>,

PreLoad: (callback: (Data) → Data) → (),

PreSave: (callback: (Data) → Data) → (),

PostGlobalUpdate: (

string,

(GlobalUpdates) → ()

) → Promise,

validate: (data: Data) → (

boolean,

string?

)

}

Stores are used to load and save Keeps from a DataStoreService:GetDataStore()

MockStore

</>

type MockStore = StoreBase

MockStores are used to mirror the real store, but doesn't save data

Store

</>

type Store = StoreBase&{Mock: MockStore}

Stores are used to load and save Keeps from a DataStoreService:GetDataStore()

Properties

Mock

</>

Store.Mock: MockStore

A mock store that mirrors the real store, but doesn't save data

validate

</>

Store.validate: ({[string]: any}) → true | (false&string)

Used to validate data before saving. Ex. type guards

keepStore.validate = function(data)
	for key, value in data do
		local dataTempVersion = dataTemplate[key]

		if typeof(data[key]) ~= typeof(dataTempVersion) then
			return false, `Invalid type for key: {key}`
		end
	end

	return true
end

Functions

LoadKeep

</>

Store:LoadKeep(

key: string,

unreleasedHandler: unreleasedHandler?

) → Promise<Keep?>

Loads a Keep from the store and returns a Keep object

keepStore:LoadKeep(`Player_{player.UserId}`, function()
	return DataKeep.LoadMethods.ForceLoad
end)):andThen(function(keep)
	if not keep then
		player:Kick("Session lock interrupted!")
		return
	end

	print(`Loaded {keep:Identify()}!`)
end)

info

Stores can be loaded multiple times as they are cached, that way you can call :LoadKeep() and get the same cached Keeps.

ViewKeep

</>

Store:ViewKeep(

key: string,

version: string?

) → Promise<Keep>

Loads a Keep from the store and returns a Keep object, but doesn't save it

View-only Keeps have the same functions as normal Keeps, but can not operate on data

keepStore:ViewKeep(`Player_{player.UserId}`):andThen(function(viewOnlyKeep)
	print(`Viewing {viewOnlyKeep:Identify()}!`)
end)

warning

View-only Keeps are not cached!

warning

Keep:Destroy() must be called when view-only Keep is not needed anymore.

PreLoad

</>

Store:PreLoad(callback: ({[string]: any}) → {[string]: any}) → ()

Runs before loading a Keep, allowing you to modify the data before, like decompressing compressed data

caution

Callback must return a new data table.

warning

:PreLoad() can only be set once.

Decompression example:

keepStore:PreLoad(function(data)
	local newData = {}

	for key, value in data do
		newData[key] = HttpService:JSONDecode(value)
	end

	return newData
end)

PreSave

</>

Store:PreSave(callback: ({[string]: any}) → {[string]: any}) → ()

Runs before saving a Keep, allowing you to modify the data before, like compressing data

caution

Callback must return a new data table.

warning

:PreSave() can only be set once.

Compression example:

keepStore:PreSave(function(data)
	local newData = {}

	for key, value in data do
		newData[key] = HttpService:JSONEncode(value)
	end

	return newData
end)

PostGlobalUpdate

</>

Store:PostGlobalUpdate(

key: string,

updateHandler: (GlobalUpdates) → ()

) → Promise<updatedData,DataStoreKeyInfo>

Posts a global update to a Keep

updateHandler reveals globalUpdates to the API

keepStore:PostGlobalUpdate(`Player_{player.UserId}`, function(globalUpdates)
	globalUpdates:AddGlobalUpdate({
		Hello = "World!",
	}):andThen(function(updateId)
		print("Added Global Update!")
	end)
end)