@quenty/servicebag
v11.13.6
Service providing mechanisms for Nevermore
0/weekUpdated 3 weeks agoMITUnpacked: 36.4 KB
Published by quenty
npm install @quenty/servicebagServiceBag
Service providing mechanisms for Nevermore
Installation
``
npm install @quenty/servicebag --save
Goals
- Remove requirement for many services to be loaded
- Make installing new modules really easy
- Make testing easier
- Reduce maintaince costs
- Explicitly declare service pattern
- Force declaration of service usage
- Make it easy to trace service dependenciesRequirements
- Initialize dependent services using
- Start dependent services using
- Retrieve services is easy
- Don't have to list off every service in the game
- Services don't load until we ask them to
- Circular dependencies allowedLike-to-have
- Dependency injection for tests
- Works with type system
- Async initialization (return promises instead of blocking)
- Dependency graph safe (i.e. recursive service requirement )
- Services are protected from another service erroringStretch goals
- Handles services for actors (remove global code)Ideas
- Inject a ServiceBagRules
1. Each service will be identified by its module
2. Each service will be initialized once
3. If we require a service, we will not have to declare subservices
lua
-- Main script
local serviceBag = require("ServiceBag").new()serviceBag:AddService(require("TransparencyService"))
serviceBag:Init()
serviceBag:Start()
`lua
-- Other script
local TransparencyService = require("TransparencyService") -- force declaration at toplocal TestClass = {}
TestClass.ClassName = "TestClass"
TestClass.__index = TestClass
function TestClass.new(serviceBag)
local self = setmetatable({}, TestClass)
self._serviceProvider = assert(serviceBag, "No serviceBag")
self._transparencyService = self._serviceProvider:GetRequiredService(TransparencyService)
return self
end
return TestClass
`lua
local DialogPane = setmetatable({}, BasicPane)
DialogPane.ClassName = "DialogPane"
DialogPane.__index = DialogPanefunction DialogPane.new(serviceBag)
local self = setmetatable(BasicPane.new(serviceBag:GetService(DialogTemplatesClient):Clone("DialogPaneTemplate")), DialogPane)
self._theme = Instance.new("StringValue")
self._theme.Value = "Light"
self._maid:GiveTask(self._theme)
self._dialogInput = DialogInput.new()
self._maid:GiveTask(self._dialogInput)
``Classes versus singletons
Right now services and classes aren't the same. There's no contract to transform a class with lifetime
into a service. However, because some of our services actually implement a .new() method (i.e. service definitions can be classes), we can't differentiate easily.
The issue is around life-cycle.
1. Service.new() can either be a constructor which establishes just data for the service or...
2. Service.new() can actually establish state data.
Other service providers solve this issue by doing the following...
1. Separating out the service identifier from the actual service definition (interfaces)
2. Separating out the addition of services from the actual services
We inherently don't want to separate out interfaces yet because we don't know what the actors or tie-interfaces for hot reloading will even look like.
It's important that we don't define this yet because there's a good chance separation at the service layer will be very important (i.e. we'll want to observe service state existing).
$3
We could establish a contract that providing an interface will be allowed. That is, a service can return a value it'd like to use as an interface instead. We may need to wait until we resolve these other problems first.
Major changes in the future
1. Require-by-name
1. Interfaces as definition
2. Hot reloading
3. Async interfaces