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()

Store

</>

type Store = {

Mock: MockStore,

LoadKeep: (

string,

unreleasedHandler?

) → Promise<Keep>,

ViewKeep: (string) → Promise<Keep>,

PreSave: (({any}) → {any}) → nil,

PreLoad: (({any}) → {any}) → nil,

PostGlobalUpdate: (

string,

(GlobalUpdates) → nil

) → Promise<void>,

IssueSignal: Signal,

CriticalStateSignal: Signal,

CriticalState: boolean

}

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

unreleasedHandler

</>

type unreleasedHandler = (Keep.ActiveSession) → "ForceLoad" | "Cancel"

Used to determine how to handle an session locked Keep

Default: "ForceLoad"

"ForceLoad"

Steals the lock, releasing the previous session. It can take up to around 2 auto save cycles (1 on session that is requesting and 1 on session that already owns the lock) to release previous session and save new one if session is locked and up to around 10 minutes if session is in dead lock

"Cancel"

Cancels the load of the Keep

Properties

Wrapper

</>

Store.Wrapper: {}

Wrapper functions that are inheritted by Keeps when they are loaded

info

Any wrapper changes post :GetStore() will not apply to that store but the next one.

Mock

</>

Store.Mock: MockStore

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

IssueSignal

</>

Store.IssueSignal: Signal

Fired when an issue occurs, like a failed request

keepStore.IssueSignal:Connect(function(err)
	print("Issue!", err)
end)

CriticalStateSignal

</>

Store.CriticalStateSignal: Signal

Fired when the store enters critical state. After it has failed many requests and maybe dangerous to proceed with purchases or other important actions

keepStore.CriticalStateSignal:Connect(function()
	print("Critical State!")
end)

CriticalState

</>

Store.CriticalState: boolean

Whether the store is in critical state or not. See CriticalStateSignal

if keepStore.CriticalState then
	warn("Critical State!")
	return
end

-- process purchase

validate

</>

Store.validate: (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

GetStore

</>

Store.GetStore(

storeInfo: StoreInfo | string,

dataTemplate: any

) → Promise<Store>

Loads a store from a DataStoreService:GetDataStore() and returns a Store object

local keepStore = DataKeep.GetStore("TestStore", {
	Test = "Hello World!",
}):expect()

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)
	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)

PreSave

</>

Store:PreSave(callback: ({any}) → {any: any}) → ()

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

caution

Functions must return a new data table. Failure to do so will result in data loss.

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)

PreLoad

</>

Store:PreLoad(callback: ({any}) → {any: any}) → ()

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

caution

Functions must return a new data table. Failure to do so will result in data loss.

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)

PostGlobalUpdate

</>

Store:PostGlobalUpdate(

key: string,

updateHandler: (GlobalUpdates) → nil

) → Promise<void>

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)