@quenty/gameproductservice 5.15.0 → 6.0.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [6.0.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/gameproductservice@5.15.0...@quenty/gameproductservice@6.0.0) (2023-02-27)
+
+**Note:** Version bump only for package @quenty/gameproductservice
+
+
+
+
+
 # [5.15.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/gameproductservice@5.14.0...@quenty/gameproductservice@5.15.0) (2023-02-27)
 
 **Note:** Version bump only for package @quenty/gameproductservice

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/gameproductservice",
-  "version": "5.15.0",
+  "version": "6.0.0",
   "description": "Generalized monetization system for handling products and purchases correctly.",
   "keywords": [
     "Roblox",
@@ -34,6 +34,7 @@
     "@quenty/loader": "^6.1.0",
     "@quenty/maid": "^2.4.0",
     "@quenty/marketplaceutils": "^6.2.0",
+    "@quenty/observablecollection": "^5.8.0",
     "@quenty/playerbinder": "^8.8.0",
     "@quenty/promise": "^6.2.0",
     "@quenty/remoting": "^6.2.0",
@@ -42,7 +43,8 @@
     "@quenty/servicebag": "^6.5.0",
     "@quenty/signal": "^2.3.0",
     "@quenty/statestack": "^8.6.0",
+    "@quenty/string": "^3.1.0",
     "@quenty/table": "^3.2.0"
   },
-  "gitHead": "62c1fdb2f329ca6d6395b63a56a5dfacb3831349"
+  "gitHead": "ef2767286911d37d3584dd21efee66b88061cb6e"
 }

package/src/Client/GameProductServiceClient.lua

@@ -1,20 +1,35 @@
 --[=[
+	This service provides an interface to purchase produces, assets, and other
+	marketplace items. This listens to events, handles requests between server and
+	client, and takes in both assetKeys from GameConfigService, as well as
+	assetIds.
+
+	See [GameProductService] for the server equivalent. The API surface should be
+	effectively the same between the two.
+
+	@client
 	@class GameProductServiceClient
 ]=]
 
 local require = require(script.Parent.loader).load(script)
 
 local Players = game:GetService("Players")
-local MarketplaceService = game:GetService("MarketplaceService")
 
-local Maid = require("Maid")
-local GameProductServiceBase = require("GameProductServiceBase")
-local Signal = require("Signal")
 local GameConfigAssetTypes = require("GameConfigAssetTypes")
+local Maid = require("Maid")
 local Promise = require("Promise")
+local RxBinderUtils = require("RxBinderUtils")
+local Signal = require("Signal")
+local GameProductServiceHelper = require("GameProductServiceHelper")
+local GameConfigAssetTypeUtils = require("GameConfigAssetTypeUtils")
 
-local GameProductServiceClient = GameProductServiceBase.new()
+local GameProductServiceClient = {}
+GameProductServiceClient.ServiceName = "GameProductServiceClient"
 
+--[=[
+	Initializes the service. Should be done via [ServiceBag]
+	@param serviceBag ServiceBag
+]=]
 function GameProductServiceClient:Init(serviceBag)
 	assert(not self._serviceBag, "Already initialized")
 	self._serviceBag = assert(serviceBag, "No serviceBag")
@@ -26,151 +41,158 @@ function GameProductServiceClient:Init(serviceBag)
 	-- Internal
 	self._binders = self._serviceBag:GetService(require("GameProductBindersClient"))
 
-	self.GamepassPurchased = Signal.new() -- :Fire(gamepassId)
-	self._maid:GiveTask(self.GamepassPurchased)
-
-	self.DevProductPurchased = Signal.new() -- :Fire(productId)
-	self._maid:GiveTask(self.DevProductPurchased)
-
-	self._promptClosedEvent = Signal.new()
-	self._maid:GiveTask(self._promptClosedEvent)
-
-	self._purchasedGamePassesThisSession = {}
-	self._maid:GiveTask(MarketplaceService.PromptGamePassPurchaseFinished
-		:Connect(function(player, gamepassId, wasPurchased)
-			if player == Players.LocalPlayer then
-				self._promptClosedEvent:Fire()
-				if wasPurchased then
-					self._purchasedGamePassesThisSession[gamepassId] = true
-					-- self._fireworksService:Create(3)
-					self.GamepassPurchased:Fire(gamepassId)
-				end
-			end
-		end))
-
-	self._purchasedDevProductsThisSession = {}
-	self._maid:GiveTask(MarketplaceService.PromptProductPurchaseFinished
-		:Connect(function(userId, productId, wasPurchased)
-			if userId == Players.LocalPlayer.UserId then
-				self._promptClosedEvent:Fire()
-				if wasPurchased then
-					-- self._fireworksService:Create(3)
-					self._purchasedDevProductsThisSession[productId] = true
-					self.DevProductPurchased:Fire(productId)
-				end
-			end
-		end))
+	self._helper = GameProductServiceHelper.new(self._binders.PlayerProductManager)
+	self._maid:GiveTask(self._helper)
+
+	-- Additional API for ergonomics
+	self.GamePassPurchased = Signal.new() -- :Fire(gamePassId)
+	self._maid:GiveTask(self.GamePassPurchased)
+
+	self.ProductPurchased = Signal.new() -- :Fire(productId)
+	self._maid:GiveTask(self.ProductPurchased)
+
+	self.AssetPurchased = Signal.new() -- :Fire(assetId)
+	self._maid:GiveTask(self.AssetPurchased)
+
+	self.BundlePurchased = Signal.new() -- :Fire(bundleId)
+	self._maid:GiveTask(self.BundlePurchased)
 end
 
 --[=[
-	Promises whether the local player owns the pass or not
-	@param passIdOrKey string | number
-	@return Promise<boolean>
+	Starts the service. Should be done via [ServiceBag]
 ]=]
-function GameProductServiceClient:PromiseLocalPlayerOwnsPass(passIdOrKey)
-	assert(type(passIdOrKey) == "number" or type(passIdOrKey) == "string", "Bad passIdOrKey")
+function GameProductServiceClient:Start()
+	self._maid:GiveTask(RxBinderUtils.observeBoundClassBrio(self._binders.PlayerProductManager, Players.LocalPlayer):Subscribe(function(brio)
+		if brio:IsDead() then
+			return
+		end
+
+		local maid = brio:ToMaid()
+		local playerProductManager = brio:GetValue()
+		local playerMrketeer = playerProductManager:GetMarketeer()
+
+		local function exposeSignal(signal, assetType)
+			maid:GiveTask(playerMrketeer:GetAssetTrackerOrError(assetType).Purchased:Connect(function(...)
+				signal:Fire(...)
+			end))
+		end
+
+		exposeSignal(self.GamePassPurchased, GameConfigAssetTypes.PASS)
+		exposeSignal(self.ProductPurchased, GameConfigAssetTypes.PRODUCT)
+		exposeSignal(self.AssetPurchased, GameConfigAssetTypes.ASSET)
+		exposeSignal(self.BundlePurchased, GameConfigAssetTypes.BUNDLE)
+	end))
+end
 
-	local passId = self:ToAssetId(GameConfigAssetTypes.PASS, passIdOrKey)
-	if not passId then
-		return Promise.rejected(("No asset with key %q"):format(tostring(passIdOrKey)))
-	end
+--[=[
+	Returns true if item has been purchased this session
 
-	if self._purchasedGamePassesThisSession[passId] == true then
-		return Promise.resolved(self._purchasedGamePassesThisSession[passId])
-	end
+	@param player Player
+	@param assetType GameConfigAssetType
+	@param idOrKey string | number
+	@return boolean
+]=]
+function GameProductServiceClient:HasPlayerPurchasedThisSession(player, assetType, idOrKey)
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(GameConfigAssetTypeUtils.isAssetType(assetType), "Bad assetType")
+	assert(type(idOrKey) == "number" or type(idOrKey) == "string", "Bad idOrKey")
 
-	return self:PromisePlayerOwnsPass(Players.LocalPlayer, passId)
+	return self._helper:HasPlayerPurchasedThisSession(player, assetType, idOrKey)
 end
 
 --[=[
-	Observes whether the local player owns the pass or not
-	@param passIdOrKey string | number
-	@return Observable<boolean>
+	Prompts the user to purchase the asset, and returns true if purchased
+
+	@param player Player
+	@param assetType GameConfigAssetType
+	@param idOrKey string | number
+	@return Promise<boolean>
 ]=]
-function GameProductServiceBase:ObserveLocalPlayerOwnsPass(passIdOrKey)
-	assert(type(passIdOrKey) == "number" or type(passIdOrKey) == "string", "Bad passIdOrKey")
+function GameProductServiceClient:PromisePromptPurchase(player, assetType, idOrKey)
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(GameConfigAssetTypeUtils.isAssetType(assetType), "Bad assetType")
+	assert(type(idOrKey) == "number" or type(idOrKey) == "string", "Bad idOrKey")
 
-	return self:ObservePlayerOwnsPass(Players.LocalPlayer, passIdOrKey)
-end
 
-function GameProductServiceClient:GetPlayerProductManagerBinder()
-	return self._binders.PlayerProductManager
+	return self._helper:PromisePromptPurchase(player, assetType, idOrKey)
 end
 
-function GameProductServiceClient:FlagPromptOpen()
-	assert(self ~= GameProductServiceClient, "Use serviceBag")
-	assert(self._serviceBag, "Not initialized")
+--[=[
+	Returns true if item has been purchased this session
 
-	self._promptOpenFlag = true
+	@param player Player
+	@param assetType GameConfigAssetType
+	@param idOrKey string | number
+	@return Promise<boolean>
+]=]
+function GameProductServiceClient:PromisePlayerOwnership(player, assetType, idOrKey)
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(GameConfigAssetTypeUtils.isAssetType(assetType), "Bad assetType")
+	assert(type(idOrKey) == "number" or type(idOrKey) == "string", "Bad idOrKey")
+
+	return self._helper:PromisePromptPurchase(player, assetType, idOrKey)
 end
 
-function GameProductServiceClient:GuessIfPromptOpenFromFlags()
-	assert(self ~= GameProductServiceClient, "Use serviceBag")
-	assert(self._serviceBag, "Not initialized")
+--[=[
+	Observes if the player owns this cloud asset or not
 
-	return self._promptOpenFlag
+	@param player Player
+	@param assetType GameConfigAssetType
+	@param idOrKey string | number
+	@return Observable<boolean>
+]=]
+function GameProductServiceClient:ObservePlayerOwnership(player, assetType, idOrKey)
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(GameConfigAssetTypeUtils.isAssetType(assetType), "Bad assetType")
+	assert(type(idOrKey) == "number" or type(idOrKey) == "string", "Bad idOrKey")
+
+	return self._helper:ObservePlayerOwnership(player, assetType, idOrKey)
 end
 
-function GameProductServiceClient:HasPurchasedProductThisSession(productIdOrKey)
+--[=[
+	Flags the propmt is open
+]=]
+function GameProductServiceClient:FlagPromptOpen()
 	assert(self ~= GameProductServiceClient, "Use serviceBag")
 	assert(self._serviceBag, "Not initialized")
-	assert(type(productIdOrKey) == "number" or type(productIdOrKey) == "string", "productIdOrKey")
-
-	local productId = self:ToAssetId(GameConfigAssetTypes.PRODUCT, productIdOrKey)
-	if not productId then
-		warn(("No asset with key %q"):format(tostring(productIdOrKey)))
-		return false
-	end
-
-	if self._purchasedDevProductsThisSession[productIdOrKey] then
-		return true
-	end
 
-	return false
+	self._promptOpenFlag = true
 end
 
-function GameProductServiceClient:PromisePurchasedOrPrompt(passIdOrKey)
-	local gamepassId = self:ToAssetId(GameConfigAssetTypes.PASS, passIdOrKey)
-	if not gamepassId then
-		return Promise.rejected(("No asset with key %q"):format(tostring(passIdOrKey)))
-	end
 
-	return self:PromiseLocalPlayerOwnsPass(gamepassId)
-		:Then(function(owned)
-			if not owned then
-				MarketplaceService:PromptGamePassPurchase(Players.LocalPlayer, gamepassId)
-			end
+--[=[
+	Returns true if the prompt is open
+	@return boolean
+]=]
+function GameProductServiceClient:GuessIfPromptOpenFromFlags()
+	assert(self ~= GameProductServiceClient, "Use serviceBag")
+	assert(self._serviceBag, "Not initialized")
 
-			return owned
-		end)
+	return self._promptOpenFlag
 end
 
-function GameProductServiceClient:PromiseGamepassOrProductUnlockOrPrompt(passIdOrKey, productIdOrKey)
-	assert(passIdOrKey, "Bad passIdOrKey")
-	assert(productIdOrKey, "Bad productIdOrKey")
-
-	local productId = self:ToAssetId(GameConfigAssetTypes.PRODUCT, productIdOrKey)
-	if not productId then
-		return Promise.rejected(("No asset with key %q"):format(tostring(productIdOrKey)))
-	end
+--[=[
+	Promises to either check a gamepass or a product to see if it's purchased.
 
-	local gamepassId = self:ToAssetId(GameConfigAssetTypes.PASS, passIdOrKey)
-	if not gamepassId then
-		return Promise.rejected(("No asset with key %q"):format(tostring(passIdOrKey)))
-	end
+	@param gamePassIdOrKey string | number
+	@param productIdOrKey string | number
+	@return boolean
+]=]
+function GameProductServiceClient:PromiseGamePassOrProductUnlockOrPrompt(gamePassIdOrKey, productIdOrKey)
+	assert(type(gamePassIdOrKey) == "number" or type(gamePassIdOrKey) == "string", "Bad gamePassIdOrKey")
+	assert(type(productIdOrKey) == "number" or type(productIdOrKey) == "string", "Bad productIdOrKey")
 
-	if self:HasPurchasedProductThisSession(productId) then
+	if self:HasPurchasedThisSession(Players.LocalPlayer, GameConfigAssetTypes.PRODUCT, productIdOrKey) then
 		return Promise.resolved(true)
 	end
 
-	return self:PromiseLocalPlayerOwnsPass(gamepassId)
-		:Then(function(owned)
-			if owned then
-				return owned
+	return self:PromisePlayerOwnership(Players.LocalPlayer, GameConfigAssetTypes.PASS, productIdOrKey)
+		:Then(function(owns)
+			if owns then
+				return true
+			else
+				return self:PromisePromptPurchase(Players.LocalPlayer, GameConfigAssetTypes.PRODUCT, productIdOrKey)
 			end
-
-			MarketplaceService:PromptProductPurchase(Players.LocalPlayer, productId)
-			return owned
 		end)
 end
 

package/src/Client/Manager/PlayerProductManagerClient.lua

@@ -8,102 +8,97 @@ local require = require(script.Parent.loader).load(script)
 local MarketplaceService = game:GetService("MarketplaceService")
 local Players = game:GetService("Players")
 
-local PlayerProductManagerBase = require("PlayerProductManagerBase")
+local BaseObject = require("BaseObject")
 local PlayerProductManagerConstants = require("PlayerProductManagerConstants")
 local GameConfigServiceClient = require("GameConfigServiceClient")
-local Promise = require("Promise")
+local GameConfigAssetTypes = require("GameConfigAssetTypes")
+local PlayerMarketeer = require("PlayerMarketeer")
 
-local PlayerProductManagerClient = setmetatable({}, PlayerProductManagerBase)
+local PlayerProductManagerClient = setmetatable({}, BaseObject)
 PlayerProductManagerClient.ClassName = "PlayerProductManagerClient"
 PlayerProductManagerClient.__index = PlayerProductManagerClient
 
 require("PromiseRemoteEventMixin"):Add(PlayerProductManagerClient, PlayerProductManagerConstants.REMOTE_EVENT_NAME)
 
 function PlayerProductManagerClient.new(obj, serviceBag)
-	local self = setmetatable(PlayerProductManagerBase.new(obj), PlayerProductManagerClient)
+	local self = setmetatable(BaseObject.new(obj), PlayerProductManagerClient)
 
 	self._serviceBag = assert(serviceBag, "No serviceBag")
 	self._gameConfigServiceClient = self._serviceBag:GetService(GameConfigServiceClient)
 
-
 	if self._obj == Players.LocalPlayer then
-		self._pendingPassPromises = {}
+		self._marketeer = PlayerMarketeer.new(self._obj, self._gameConfigServiceClient:GetConfigPicker())
+		self._maid:GiveTask(self._marketeer)
 
-		self:PromiseRemoteEvent():Then(function(remoteEvent)
-			self:_setupRemoteEventLocal(remoteEvent)
-		end)
+		self:_connectMarketplace()
 
-		self._maid:GiveTask(MarketplaceService.PromptGamePassPurchaseFinished:Connect(function(player, gamePassId, isPurchased)
-			if player == self._obj then
-				self:_handlePassFinished(player, gamePassId, isPurchased)
-			end
-		end))
+		-- Configure remote events
+		self:_replicateRemoteEventType(GameConfigAssetTypes.ASSET)
+		self:_replicateRemoteEventType(GameConfigAssetTypes.BUNDLE)
+		self:_replicateRemoteEventType(GameConfigAssetTypes.PASS)
+		self:_replicateRemoteEventType(GameConfigAssetTypes.PRODUCT)
 	end
 
 	return self
 end
 
-function PlayerProductManagerClient:PromptGamePassPurchase(gamePassId)
-	assert(type(gamePassId) == "number", "Bad gamePassId")
-	assert(self._obj == Players.LocalPlayer, "Can only prompt local player")
-
-	if self._pendingPassPromises[gamePassId] then
-		return self._maid:GivePromise(self._pendingPassPromises[gamePassId])
-	end
+--[=[
+	@return PlayerMarketeer
+]=]
+function PlayerProductManagerClient:GetMarketeer()
+	return self._marketeer
+end
 
-	MarketplaceService:PromptGamePassPurchase(self._obj, gamePassId)
-	local promise = Promise.new()
+function PlayerProductManagerClient:_replicateRemoteEventType(assetType)
+	local tracker = self._marketeer:GetAssetTrackerOrError(assetType)
 
-	self._pendingPassPromises[gamePassId] = promise
+	self._maid:GiveTask(tracker.PromptFinished:Connect(function(assetId, isPurchased)
+		self:PromiseRemoteEvent():Then(function(remoteEvent)
+			remoteEvent:FireServer(PlayerProductManagerConstants.NOTIFY_PROMPT_FINISHED, assetType, assetId, isPurchased)
+		end)
+	end))
+end
 
-	return self._maid:GivePromise(promise)
+--[=[
+	Gets the current player
+	@return Player
+]=]
+function PlayerProductManagerClient:GetPlayer()
+	return self._obj
 end
 
-function PlayerProductManagerClient:_setupRemoteEventLocal(remoteEvent)
-	-- Gear and other assets
+function PlayerProductManagerClient:_connectMarketplace()
+	-- Assets
 	self._maid:GiveTask(MarketplaceService.PromptPurchaseFinished:Connect(function(player, assetId, isPurchased)
 		if player == self._obj then
-			remoteEvent:FireServer(PlayerProductManagerConstants.NOTIFY_PROMPT_FINISHED, assetId, isPurchased)
+			local tracker = self._marketeer:GetAssetTrackerOrError(GameConfigAssetTypes.ASSET)
+			tracker:HandlePurchaseEvent(assetId, isPurchased)
 		end
 	end))
 
 	-- Products
-	self._maid:GiveTask(MarketplaceService.PromptProductPurchaseFinished:Connect(function(userId, assetId, isPurchased)
+	self._maid:GiveTask(MarketplaceService.PromptProductPurchaseFinished:Connect(function(userId, productId, isPurchased)
 		if self._obj.UserId == userId then
-			remoteEvent:FireServer(PlayerProductManagerConstants.NOTIFY_PROMPT_FINISHED, assetId, isPurchased)
+			local tracker = self._marketeer:GetAssetTrackerOrError(GameConfigAssetTypes.PRODUCT)
+			tracker:HandlePurchaseEvent(productId, isPurchased)
 		end
 	end))
 
-	-- Gamepasses
+	-- Game passes
 	self._maid:GiveTask(MarketplaceService.PromptGamePassPurchaseFinished:Connect(function(player, gamePassId, isPurchased)
 		if player == self._obj then
-			remoteEvent:FireServer(PlayerProductManagerConstants.NOTIFY_GAMEPASS_FINISHED, gamePassId, isPurchased)
+			local tracker = self._marketeer:GetAssetTrackerOrError(GameConfigAssetTypes.PASS)
+			tracker:HandlePurchaseEvent(gamePassId, isPurchased)
 		end
 	end))
-end
-
--- For overrides
-function PlayerProductManagerClient:GetConfigPicker()
-	return self._gameConfigServiceClient:GetConfigPicker()
-end
 
-function PlayerProductManagerClient:_handlePassFinished(player, gamePassId, isPurchased)
-	assert(typeof(player) == "Instance", "Bad player")
-	assert(type(gamePassId) == "number", "Bad gamePassId")
-	assert(type(isPurchased) == "boolean", "Bad isPurchased")
-
-	local promise = self._pendingPassPromises[gamePassId]
-	if promise then
-		if isPurchased then
-			-- TODO: verify this on the server here
-			-- Can we break cache?
-			self:SetPlayerOwnsPass(gamePassId, true)
+	-- Bundles
+	self._maid:GiveTask(MarketplaceService.PromptBundlePurchaseFinished:Connect(function(player, bundleId, isPurchased)
+		if player == self._obj then
+			local tracker = self._marketeer:GetAssetTrackerOrError(GameConfigAssetTypes.BUNDLE)
+			tracker:HandlePurchaseEvent(bundleId, isPurchased)
 		end
-
-		self._pendingPassPromises[gamePassId] = nil
-		promise:Resolve(isPurchased)
-	end
+	end))
 end
 
-
 return PlayerProductManagerClient

package/src/Server/GameProductService.lua

@@ -1,4 +1,13 @@
 --[=[
+	This service provides an interface to purchase produces, assets, and other
+	marketplace items. This listens to events, handles requests between server and
+	client, and takes in both assetKeys from GameConfigService, as well as
+	assetIds.
+
+	See [GameProductServiceClient] for the client equivalent. The API surface should be
+	effectively the same between the two.
+
+	@server
 	@class GameProductService
 ]=]
 
@@ -7,11 +16,17 @@ local require = require(script.Parent.loader).load(script)
 local Players = game:GetService("Players")
 local MarketplaceService = game:GetService("MarketplaceService")
 
-local GameProductServiceBase = require("GameProductServiceBase")
 local Maid = require("Maid")
+local GameProductServiceHelper = require("GameProductServiceHelper")
+local GameConfigAssetTypeUtils = require("GameConfigAssetTypeUtils")
 
-local GameProductService = GameProductServiceBase.new()
+local GameProductService = {}
+GameProductService.ServiceName = "GameProductService"
 
+--[=[
+	Initializes the service. Should be done via [ServiceBag]
+	@param serviceBag ServiceBag
+]=]
 function GameProductService:Init(serviceBag)
 	assert(not self._serviceBag, "Already initialized")
 
@@ -23,21 +38,93 @@ function GameProductService:Init(serviceBag)
 
 	-- Internal
 	self._binders = self._serviceBag:GetService(require("GameProductBindersServer"))
+
+	-- Configure
+	self._helper = GameProductServiceHelper.new(self._binders.PlayerProductManager)
+	self._maid:GiveTask(self._helper)
 end
 
+--[=[
+	Starts the service. Should be done via [ServiceBag]
+]=]
 function GameProductService:Start()
+	-- TODO: Avoid binding this unless explicitly asked to
+	-- TODO: Provide receipt processing API surface
+
 	MarketplaceService.ProcessReceipt = function(...)
 		return self:_processReceipt(...)
 	end
 
 	self._maid:GiveTask(function()
-		-- This might be unsafe
-		MarketplaceService.ProcessReceipt = nil
+		task.spawn(function()
+			-- This might be unsafe
+			MarketplaceService.ProcessReceipt = nil
+		end)
 	end)
 end
 
-function GameProductService:GetPlayerProductManagerBinder()
-	return self._binders.PlayerProductManager
+--[=[
+	Returns true if item has been purchased this session
+
+	@param player Player
+	@param assetType GameConfigAssetType
+	@param idOrKey string | number
+	@return boolean
+]=]
+function GameProductService:HasPlayerPurchasedThisSession(player, assetType, idOrKey)
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(GameConfigAssetTypeUtils.isAssetType(assetType), "Bad assetType")
+	assert(type(idOrKey) == "number" or type(idOrKey) == "string", "Bad idOrKey")
+
+	return self._helper:HasPlayerPurchasedThisSession(player, assetType, idOrKey)
+end
+
+--[=[
+	Prompts the user to purchase the asset, and returns true if purchased
+
+	@param player Player
+	@param assetType GameConfigAssetType
+	@param idOrKey string | number
+	@return boolean
+]=]
+function GameProductService:PromisePlayerPromptPurchase(player, assetType, idOrKey)
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(GameConfigAssetTypeUtils.isAssetType(assetType), "Bad assetType")
+	assert(type(idOrKey) == "number" or type(idOrKey) == "string", "Bad idOrKey")
+
+	return self._helper:PromisePromptPurchase(player, assetType, idOrKey)
+end
+
+--[=[
+	Returns true if item has been purchased this session
+
+	@param player Player
+	@param assetType GameConfigAssetType
+	@param idOrKey string | number
+	@return Promise<boolean>
+]=]
+function GameProductService:PromisePlayerOwnership(player, assetType, idOrKey)
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(GameConfigAssetTypeUtils.isAssetType(assetType), "Bad assetType")
+	assert(type(idOrKey) == "number" or type(idOrKey) == "string", "Bad idOrKey")
+
+	return self._helper:PromisePlayerOwnership(player, assetType, idOrKey)
+end
+
+--[=[
+	Observes if the player owns this cloud asset or not
+
+	@param player Player
+	@param assetType GameConfigAssetType
+	@param idOrKey string | number
+	@return Observable<boolean>
+]=]
+function GameProductService:ObservePlayerOwnership(player, assetType, idOrKey)
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(GameConfigAssetTypeUtils.isAssetType(assetType), "Bad assetType")
+	assert(type(idOrKey) == "number" or type(idOrKey) == "string", "Bad idOrKey")
+
+	return self._helper:ObservePlayerOwnership(player, assetType, idOrKey)
 end
 
 function GameProductService:_processReceipt(receiptInfo)