@quenty/datastore 13.28.1 → 13.28.2

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [13.28.2](https://github.com/Quenty/NevermoreEngine/compare/@quenty/datastore@13.28.1...@quenty/datastore@13.28.2) (2026-01-12)
+
+
+### Bug Fixes
+
+* Fix dependency installation process for pnpm ([9651b09](https://github.com/Quenty/NevermoreEngine/commit/9651b09af34f252ef3f9c7c539793cc878dd8cba))
+* Update DataStore to handle locking on non-locked items a bit better ([572bd59](https://github.com/Quenty/NevermoreEngine/commit/572bd59b4946fa8c1a2413a50c5402ca32e57b33))
+
+
+
+
+
 ## [13.28.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/datastore@13.28.0...@quenty/datastore@13.28.1) (2026-01-10)
 
 **Note:** Version bump only for package @quenty/datastore

package/default.project.json

@@ -1,6 +1,13 @@
 {
   "name": "datastore",
-  "globIgnorePaths": [ "**/.package-lock.json" ],
+  "globIgnorePaths": [
+    "**/.package-lock.json",
+    "**/.pnpm",
+    "**/.pnpm-workspace-state-v1.json",
+    "**/.modules.yaml",
+    "**/.ignored",
+    "**/.ignored_*"
+  ],
   "tree": {
     "$path": "src"
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/datastore",
-  "version": "13.28.1",
+  "version": "13.28.2",
   "description": "Quenty's Datastore implementation for Roblox",
   "keywords": [
     "Roblox",
@@ -29,23 +29,23 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/baseobject": "^10.9.2",
-    "@quenty/bindtocloseservice": "^8.23.1",
-    "@quenty/loader": "^10.9.2",
-    "@quenty/maid": "^3.5.2",
-    "@quenty/math": "^2.7.4",
-    "@quenty/pagesutils": "^5.13.5",
-    "@quenty/promise": "^10.12.5",
-    "@quenty/promisemaid": "^5.12.5",
-    "@quenty/rx": "^13.21.1",
-    "@quenty/servicebag": "^11.13.5",
-    "@quenty/signal": "^7.11.4",
-    "@quenty/symbol": "^3.5.1",
-    "@quenty/table": "^3.9.1",
-    "@quenty/valueobject": "^13.23.1"
+    "@quenty/baseobject": "10.9.3",
+    "@quenty/bindtocloseservice": "8.23.2",
+    "@quenty/loader": "10.9.3",
+    "@quenty/maid": "3.5.3",
+    "@quenty/math": "2.7.5",
+    "@quenty/pagesutils": "5.13.6",
+    "@quenty/promise": "10.12.6",
+    "@quenty/promisemaid": "5.12.6",
+    "@quenty/rx": "13.21.2",
+    "@quenty/servicebag": "11.13.6",
+    "@quenty/signal": "7.11.5",
+    "@quenty/symbol": "3.5.2",
+    "@quenty/table": "3.9.2",
+    "@quenty/valueobject": "13.23.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "76f1dfb1936388838b2fd734e263a6af2ae9277b"
+  "gitHead": "55f4a7407de7247aceea574de4d2f57dab70cb91"
 }

package/src/Server/DataStore.lua

@@ -66,9 +66,8 @@
 
 local require = require(script.Parent.loader).load(script)
 
-local RunService = game:GetService("RunService")
-
 local DataStoreDeleteToken = require("DataStoreDeleteToken")
+local DataStoreLockHelper = require("DataStoreLockHelper")
 local DataStorePromises = require("DataStorePromises")
 local DataStoreStage = require("DataStoreStage")
 local Maid = require("Maid")
@@ -85,7 +84,6 @@ local DEFAULT_DEBUG_WRITING = false
 
 local DEFAULT_AUTO_SAVE_TIME_SECONDS = 60 * 5
 local DEFAULT_JITTER_PROPORTION = 0.1 -- Randomly assign jitter so if a ton of players join at once we don't hit the datastore at once
-local UNLOCK_BY_DEFAULT_TIME_MULTIPLIER = 2.1
 
 local DataStore = setmetatable({}, DataStoreStage)
 DataStore.ClassName = "DataStore"
@@ -98,7 +96,7 @@ export type DataStore =
 			_userIdList: { number }?,
 			_robloxDataStore: DataStorePromises.RobloxDataStore,
 			_debugWriting: boolean,
-			_sessionLockingEnabled: boolean,
+			_sessionLockingEnabledHelper: DataStoreLockHelper.DataStoreLockHelper?,
 			_autoSaveTimeSeconds: ValueObject.ValueObject<number?>,
 			_jitterProportion: ValueObject.ValueObject<number>,
 			_syncOnSave: ValueObject.ValueObject<boolean>,
@@ -161,7 +159,15 @@ end
 function DataStore.SetSessionLockingEnabled(self: DataStore, sessionLockingEnabled: boolean)
 	assert(not self._firstLoadPromise, "Must set session locking before datastore is loaded")
 
-	self._sessionLockingEnabled = sessionLockingEnabled
+	if sessionLockingEnabled then
+		if not self._sessionLockingEnabledHelper then
+			self._sessionLockingEnabledHelper = DataStoreLockHelper.new(self)
+			self._maid._sessionLockingEnabledHelper = self._sessionLockingEnabledHelper
+		end
+	else
+		self._sessionLockingEnabledHelper = nil
+		self._maid._sessionLockingEnabledHelper = nil
+	end
 end
 
 --[=[
@@ -205,6 +211,13 @@ function DataStore.SetAutoSaveTimeSeconds(self: DataStore, autoSaveTimeSeconds:
 	self._autoSaveTimeSeconds.Value = autoSaveTimeSeconds
 end
 
+--[=[
+	Returns how frequent the data store will autosave (or sync) to the cloud.
+]=]
+function DataStore.GetAutoSaveTimeSeconds(self: DataStore): number?
+	return self._autoSaveTimeSeconds.Value
+end
+
 --[=[
 	How frequent the data store will autosave (or sync) to the cloud
 
@@ -258,7 +271,7 @@ end
 	@return Promise
 ]=]
 function DataStore.SaveAndCloseSession(self: DataStore): Promise.Promise<()>
-	assert(self._sessionLockingEnabled, "Cannot invoke unless session locking is enabled")
+	assert(self._sessionLockingEnabledHelper, "Cannot invoke unless session locking is enabled")
 
 	return self:_syncData(false, true)
 end
@@ -442,9 +455,8 @@ function DataStore._doDataSync(
 		promise:Resolve(
 			maid:GivePromise(
 				DataStorePromises.updateAsync(self._robloxDataStore, self._key, function(original, datastoreKeyInfo)
-					if self._sessionLockingEnabled then
-						original = table.clone(original)
-						original.lock = nil
+					if self._sessionLockingEnabledHelper then
+						original = self._sessionLockingEnabledHelper:ToUnlockedProfile(original)
 					end
 
 					if promise:IsRejected() then
@@ -485,15 +497,8 @@ function DataStore._doDataSync(
 						metadata = datastoreKeyInfo:GetMetadata()
 					end
 
-					if doCloseSession then
-						result = table.clone(result)
-						result.lock = nil
-					elseif self._sessionLockingEnabled then
-						-- Maintain the lock with the latest time
-						result = table.clone(result)
-						if result.lock then
-							result.lock = os.time()
-						end
+					if self._sessionLockingEnabledHelper then
+						result = self._sessionLockingEnabledHelper:ToLockedProfile(result, doCloseSession)
 					end
 
 					return result, userIdList, metadata
@@ -518,7 +523,7 @@ end
 
 function DataStore._promiseGetAsyncNoCache(self: DataStore): Promise.Promise<()>
 	local promise
-	if self._sessionLockingEnabled then
+	if self._sessionLockingEnabledHelper then
 		local function promiseLoadUnlockedProfile()
 			local loadPromise = Promise.new()
 			self._maid[loadPromise] = loadPromise
@@ -540,48 +545,17 @@ function DataStore._promiseGetAsyncNoCache(self: DataStore): Promise.Promise<()>
 							print(string.format("DataStorePromises.updateAsync(%q) -> Got ", tostring(self._key)), data)
 						end
 
-						if type(data) == "table" and data.lock then
-							local isInvalidLock = false
-							if type(data.lock) == "number" then
-								local timeElapsed = os.time() - data.lock
-								local autoSaveSeconds = self._autoSaveTimeSeconds.Value
-								if
-									autoSaveSeconds
-									and timeElapsed > (autoSaveSeconds * UNLOCK_BY_DEFAULT_TIME_MULTIPLIER)
-								then
-									isInvalidLock = true
-								end
-							end
-
-							-- Allow data locked to load in studio because otherwise testing gets really messy
-							if RunService:IsStudio() then
-								isInvalidLock = true
-							end
-
-							if not isInvalidLock then
-								loadPromise:Reject(string.format("Profile is locked (%s)", tostring(data.lock)))
-
-								-- Cancel write to avoid maintaining lock
-								return nil
-							end
-
-							-- Be sure to cleanup stuff
-							data.lock = nil :: number?
-						end
-
-						-- TODO: Retry
-						loadPromise:Resolve(data)
+						local lockResult = self._sessionLockingEnabledHelper:AcquireLock(data)
+						if not lockResult.isValid then
+							loadPromise:Reject(string.format("Profile is locked (%s)", tostring(data.lock)))
 
-						if data == nil then
-							data = {}
-						elseif type(data) ~= "table" then
-							warn("[DataStore] - Data session locking is not available for non-table entries")
-							return data, userIdList, metadata
+							-- Cancel write to avoid maintaining lock
+							return nil
 						end
 
-						data.lock = os.time()
+						loadPromise:Resolve(lockResult.unlockedProfile)
 
-						return data, userIdList, metadata
+						return lockResult.lockedProfile, userIdList, metadata
 					end)
 				)
 			end)
@@ -596,10 +570,10 @@ function DataStore._promiseGetAsyncNoCache(self: DataStore): Promise.Promise<()>
 		promise = self._maid
 			:Add(PromiseRetryUtils.retry(promiseLoadUnlockedProfile, {
 				-- https://exponentialbackoffcalculator.com/
-				-- ~10 minutes
-				exponential = 1.5,
-				initialWaitTime = 1,
-				maxAttempts = 15,
+				-- 56.294 seconds
+				exponential = 1.25,
+				initialWaitTime = 5,
+				maxAttempts = 7,
 				printWarning = true,
 			}))
 			:Catch(function(err)

package/src/Server/DataStoreLockHelper.lua

@@ -0,0 +1,123 @@
+--!strict
+--[=[
+    @class DataStoreLockHelper
+]=]
+
+local HttpService = game:GetService("HttpService")
+local RunService = game:GetService("RunService")
+
+local DataStoreLockHelper = {}
+DataStoreLockHelper.ClassName = "DataStoreLockHelper"
+DataStoreLockHelper.__index = DataStoreLockHelper
+
+local ALWAYS_STEAL_LOCKS_IN_STUDIO = false
+local UNLOCK_BY_DEFAULT_TIME_MULTIPLIER = 2.1
+
+export type DataStoreLockHelper = typeof(setmetatable(
+	{} :: {
+		_sessionId: string?,
+		_dataStore: any,
+	},
+	{} :: typeof({ __index = DataStoreLockHelper })
+))
+
+export type LockData = number
+export type ValidLockResult = {
+	isValid: true,
+	unlockedProfile: any,
+	lockedProfile: any,
+}
+
+export type InvalidLockResult = {
+	isValid: false,
+}
+
+export type AcquireLockResult = ValidLockResult | InvalidLockResult
+
+function DataStoreLockHelper.new(dataStore: any): DataStoreLockHelper
+	local self: DataStoreLockHelper = setmetatable({} :: any, DataStoreLockHelper)
+
+	self._sessionId = HttpService:GenerateGUID(false)
+	self._dataStore = dataStore
+
+	return self
+end
+
+function DataStoreLockHelper.ToUnlockedProfile(_self: DataStoreLockHelper, original: any): any
+	if original == nil then
+		return {}
+	elseif type(original) ~= "table" then
+		warn("[DataStore] - Data session locking is not available for non-table entries")
+		return original
+	else
+		local copy = table.clone(original)
+		copy.lock = nil
+		return copy
+	end
+end
+
+function DataStoreLockHelper.ToLockedProfile(_self: DataStoreLockHelper, original: any, doCloseSession: boolean?): any
+	if original == nil then
+		return {
+			lock = if doCloseSession then nil else os.time(),
+		}
+	elseif type(original) ~= "table" then
+		warn("[DataStore] - Data session locking is not available for non-table entries")
+		return original
+	else
+		local copy = table.clone(original)
+		if doCloseSession then
+			copy.lock = nil :: LockData?
+		else
+			copy.lock = os.time()
+		end
+		return copy
+	end
+end
+
+function DataStoreLockHelper.AcquireLock(self: DataStoreLockHelper, data: any): AcquireLockResult
+	if data == nil then
+		return {
+			isValid = true,
+			unlockedProfile = {},
+			lockedProfile = {
+				lock = os.time(),
+			},
+		}
+	elseif type(data) ~= "table" then
+		warn("[DataStore] - Data session locking is not available for non-table entries")
+		return {
+			isValid = true,
+			unlockedProfile = data,
+			lockedProfile = data,
+		}
+	end
+
+	local isValid = true
+	if type(data.lock) == "number" then
+		local timeElapsed = os.time() - data.lock
+		local autoSaveSeconds = self._dataStore:GetAutoSaveTimeSeconds()
+		if autoSaveSeconds and timeElapsed > (autoSaveSeconds * UNLOCK_BY_DEFAULT_TIME_MULTIPLIER) then
+			isValid = false
+		end
+	end
+
+	-- Allow data locked to load in studio because otherwise testing gets really messy
+	if ALWAYS_STEAL_LOCKS_IN_STUDIO and RunService:IsStudio() then
+		isValid = false
+	end
+
+	if isValid then
+		return {
+			isValid = true,
+			unlockedProfile = self:ToUnlockedProfile(data),
+			lockedProfile = self:ToLockedProfile(data),
+		}
+	else
+		return {
+			isValid = false,
+		}
+	end
+end
+
+return DataStoreLockHelper