DataStore Module

local RunService = game:GetService("RunService")

if RunService:IsServer() == false then error("DataStore module should be used by server.") end

local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")
local DataStoreService = game:GetService("DataStoreService")
local PlayerDataStore = DataStoreService:GetDataStore("UserData1")

export type YIELD = {[any] : any}

local SessionData = {}
local DataStoreHandler = {}

DataStoreHandler.PlayerSessionData = SessionData
DataStoreHandler.StarterData = {

}

-- FUNCTION

local function GetPlayerData(userId : number) : {any}?
    local success, data = pcall(PlayerDataStore.GetAsync,PlayerDataStore,userId)

    if not success then
        warn(data)
        local player = Players:GetPlayerByUserId(userId)

        if player then
            player:Kick(data)
        end

        return
    end

    local isDataWiped = true

    for _,_ in pairs(data) do
        isDataWiped = false
        break
    end

    if isDataWiped == true then
        print("DATA WIPE DETECTED")
        data = DataStoreHandler.StarterData
    end

    data = data or DataStoreHandler.StarterData

    if not success then
        warn(data)
        return nil
    end

    return data
end

local function CommitSavePlayerData(userId : number)
    local success, result = pcall(PlayerDataStore.SetAsync,PlayerDataStore,userId,SessionData[userId])

    if not success then
        warn(result)
    end
end

local function CommitSavePlayerDataEmpty(userId : number) : boolean
    local success, result = pcall(PlayerDataStore.SetAsync,PlayerDataStore,userId,{})

    if not success then
        warn(result)
    end

    return success
end

local function PlayerAdded(player : Player)
    SessionData[player.UserId] = GetPlayerData(player.UserId)
end

local function PlayerRemoving(player : Player)
    DataStoreHandler.SaveData(player)
    SessionData[player.UserId] = nil
end

local function BindToClose()
    while next(SessionData) ~= nil do
        RunService.Heartbeat:Wait()
    end
end

local function WipeDataAsync(userid : number)
    local playerdata = GetPlayerData(userid)

    if playerdata then
        coroutine.wrap(CommitSavePlayerDataEmpty)(userid)
    end
end

-- STATIC METHOD

function DataStoreHandler.WipeDataWithUserIdAsync(userid : number)
    coroutine.wrap(WipeDataAsync)(userid)
end

function DataStoreHandler.WipeData(player : Player)
    SessionData[player.UserId] = {}
end

function DataStoreHandler.GetDataAsync(userid : number) : YIELD
    return GetPlayerData(userid)
end

function DataStoreHandler.GetValue(player : Player, name : string) : any?
    return SessionData[player.UserId][name]
end

function DataStoreHandler.FindValue(player : Player,name : string) : any?
    return SessionData[player.UserId][name] ~= nil and SessionData[player.UserId][name]
end

function DataStoreHandler.SaveData(player : Player)
    coroutine.wrap(CommitSavePlayerData)(player.UserId)
end

function DataStoreHandler.CheckData(player : Player) : boolean
    return SessionData[player.UserId] ~= nil
end

function DataStoreHandler.WaitUntilDataLoaded(player : Player) : YIELD
    while DataStoreHandler.CheckData(player) == false do
        RunService.Heartbeat:Wait()
    end
end

function DataStoreHandler.GetData(player : Player) : any?
    return SessionData[player.UserId]
end

Players.PlayerAdded:Connect(PlayerAdded)
Players.PlayerRemoving:Connect(PlayerRemoving)

if RunService:IsServer() then
    game:BindToClose(BindToClose)
end

return DataStoreHandler