@trioforge/crucible 0.1.0 → 0.2.0

package/out/internal/data/records.luau

@@ -0,0 +1,400 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local bootClock = TS.import(script, script.Parent.Parent, "boot").bootClock
+local _admission = TS.import(script, script.Parent, "admission")
+local admitWrite = _admission.admitWrite
+local loadRecord = _admission.loadRecord
+local sealSchema = _admission.sealSchema
+local _envelope = TS.import(script, script.Parent, "envelope")
+local emptyEnvelope = _envelope.emptyEnvelope
+local envelopeBytes = _envelope.envelopeBytes
+local jsonBytes = _envelope.jsonBytes
+local parseEnvelope = _envelope.parseEnvelope
+local _limits = TS.import(script, script.Parent, "limits")
+local CALL_DEADLINE_SECONDS = _limits.CALL_DEADLINE_SECONDS
+local KEY_MAX_BYTES = _limits.KEY_MAX_BYTES
+local MAX_ENVELOPE_BYTES = _limits.MAX_ENVELOPE_BYTES
+local OPERATION_ID_MAX_AGE_SECONDS = _limits.OPERATION_ID_MAX_AGE_SECONDS
+local OPERATION_ID_MAX_BYTES = _limits.OPERATION_ID_MAX_BYTES
+local OPERATION_MARKERS_PER_KEY = _limits.OPERATION_MARKERS_PER_KEY
+local RECORD_PAYLOAD_MAX_BYTES = _limits.RECORD_PAYLOAD_MAX_BYTES
+local _operation_id = TS.import(script, script.Parent, "operation-id")
+local ageOf = _operation_id.ageOf
+local createdAt = _operation_id.createdAt
+local evictable = _operation_id.evictable
+local newOperationId = _operation_id.newOperationId
+local _session = TS.import(script, script.Parent, "session")
+local assertOutsideCallback = _session.assertOutsideCallback
+local dataCallback = _session.dataCallback
+--* @internal The failure kinds of rule 90. 
+--* @internal A generic update's result: the stored record and whether it is a replay (rule 88). 
+local function stored(current, envelope)
+	local _object = {
+		value = envelope,
+	}
+	local _left = "userIds"
+	local _result = current
+	if _result ~= nil then
+		_result = _result.userIds
+	end
+	local _condition = _result
+	if _condition == nil then
+		_condition = {}
+	end
+	_object[_left] = _condition
+	local _left_1 = "metadata"
+	local _result_1 = current
+	if _result_1 ~= nil then
+		_result_1 = _result_1.metadata
+	end
+	local _condition_1 = _result_1
+	if _condition_1 == nil then
+		_condition_1 = {}
+	end
+	_object[_left_1] = _condition_1
+	return _object
+end
+--[[
+	*
+	 * Rules 87 and 88 as one transform: it recognizes its own id, refuses an expired id or a young full ring, migrates and
+	 * admits the record, runs `change`, and stores the result with the id in one write.
+	 
+]]
+local function updateRecord(current, input, record)
+	local _binding = input
+	local schema = _binding.schema
+	local id = _binding.id
+	local _result = current
+	if _result ~= nil then
+		_result = _result.value
+	end
+	local parsed = parseEnvelope(_result, "records")
+	if parsed.kind == "unreadable" then
+		record(parsed)
+		return nil
+	end
+	local envelope = if parsed.kind == "ok" then parsed.envelope else emptyEnvelope("records")
+	if envelope.payload ~= nil and envelope.schemaVersion > schema.version then
+		record({
+			kind = "newer",
+			version = envelope.schemaVersion,
+		})
+		return nil
+	end
+	if table.find(envelope.operations, id) ~= nil then
+		record({
+			kind = "replay",
+			envelope = envelope,
+		})
+		return nil
+	end
+	local created = createdAt(id)
+	if created <= envelope.operationFloor then
+		record({
+			kind = "expired",
+		})
+		return nil
+	end
+	local operations = envelope.operations
+	local floor = envelope.operationFloor
+	if #operations >= OPERATION_MARKERS_PER_KEY then
+		local oldest = operations[1]
+		if not evictable(oldest, input.wall()) then
+			record({
+				kind = "overloaded",
+			})
+			return nil
+		end
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue = {}
+		local _callback = function(_, index)
+			return index > 0
+		end
+		local _length = 0
+		for _k, _v in operations do
+			if _callback(_v, _k - 1, operations) == true then
+				_length += 1
+				_newValue[_length] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		operations = _newValue
+		local _exp = floor
+		local _condition = createdAt(oldest)
+		if _condition == nil then
+			_condition = floor
+		end
+		floor = math.max(_exp, _condition)
+	end
+	local loaded = loadRecord(schema, envelope.payload, envelope.schemaVersion)
+	if loaded.kind ~= "ok" then
+		record({
+			kind = "unreadable",
+			reason = if loaded.kind == "unreadable" then loaded.reason else "newer",
+		})
+		return nil
+	end
+	local ok, result = pcall(function()
+		local changed = dataCallback(input.change, loaded.value, nil)
+		local unchanged = rawequal(changed, loaded.value)
+		if unchanged and not loaded.migrated then
+			return loaded.value
+		end
+		local admitted = if unchanged then loaded.value else admitWrite(schema, changed)
+		local bytes = jsonBytes(admitted)
+		if bytes > RECORD_PAYLOAD_MAX_BYTES then
+			error(`{schema.name}: {input.key}'s record is {bytes} bytes, over {RECORD_PAYLOAD_MAX_BYTES}`, 0)
+		end
+		return admitted
+	end)
+	if not ok then
+		record({
+			kind = "refused",
+			error = result,
+		})
+		return nil
+	end
+	local value = result
+	local unchanged = rawequal(value, loaded.value)
+	local keep = unchanged and not loaded.migrated
+	local _object = table.clone(envelope)
+	setmetatable(_object, nil)
+	_object.payload = if keep then envelope.payload else value
+	_object.schemaVersion = if keep then envelope.schemaVersion else schema.version
+	local _left = "operations"
+	local _array = {}
+	local _length = #_array
+	local _operationsLength = #operations
+	table.move(operations, 1, _operationsLength, _length + 1, _array)
+	_length += _operationsLength
+	_array[_length + 1] = id
+	_object[_left] = _array
+	_object.operationFloor = floor
+	local written = _object
+	local bytes = envelopeBytes(written)
+	if bytes > MAX_ENVELOPE_BYTES then
+		record({
+			kind = "too-large",
+			bytes = bytes,
+		})
+		return nil
+	end
+	record({
+		kind = "written",
+		value = value,
+		bytes = bytes,
+	})
+	return stored(current, written)
+end
+--* @internal Keyed records with no session and no lease (rules 85 to 91): `read` and `update`, each one scheduled request. 
+local RecordStore
+do
+	RecordStore = setmetatable({}, {
+		__tostring = function()
+			return "RecordStore"
+		end,
+	})
+	RecordStore.__index = RecordStore
+	function RecordStore.new(...)
+		local self = setmetatable({}, RecordStore)
+		return self:constructor(...) or self
+	end
+	function RecordStore:constructor(engine, schema)
+		self.engine = engine
+		self.sizes = {}
+		self.schema = sealSchema(schema)
+	end
+	function RecordStore:check(key)
+		local _key = key
+		local _condition = not (type(_key) == "string")
+		if not _condition then
+			_condition = #key < 1 or #key > KEY_MAX_BYTES
+		end
+		if _condition then
+			error(`{self.schema.name}: a key is 1 to {KEY_MAX_BYTES} bytes`, 3)
+		end
+		return key
+	end
+	function RecordStore:weigh(key)
+		local _sizes = self.sizes
+		local _key = key
+		local _condition = _sizes[_key]
+		if _condition == nil then
+			_condition = 0
+		end
+		return math.max(_condition, 1024)
+	end
+	function RecordStore:remember(key, bytes)
+		if bytes > 4096 then
+			local _sizes = self.sizes
+			local _key = key
+			local _bytes = bytes
+			_sizes[_key] = _bytes
+		else
+			local _sizes = self.sizes
+			local _key = key
+			_sizes[_key] = nil
+		end
+	end
+	function RecordStore:unavailable(key, code, reason)
+		self.engine:diagnose(`record:{self.schema.name}:{code}`, `{self.schema.name}: {key} {reason}`)
+		return {
+			kind = "unavailable",
+		}
+	end
+	function RecordStore:read(key)
+		self:check(key)
+		local deadline = bootClock() + CALL_DEADLINE_SECONDS
+		local ticket = self.engine.scheduler:submit({
+			store = self.schema.name,
+			key = key,
+			priority = 5,
+			kind = "read",
+			dispatchDeadline = deadline,
+			bytes = self:weigh(key),
+		})
+		local settled = ticket:wait(deadline) or {
+			kind = if ticket.dispatched then "uncertain" else "timeout",
+		}
+		if settled.kind ~= "done" then
+			return {
+				kind = settled.kind,
+			}
+		end
+		if settled.outcome.kind == "error" then
+			return {
+				kind = "unavailable",
+			}
+		end
+		local _result = settled.outcome.value
+		if _result ~= nil then
+			_result = _result.value
+		end
+		local parsed = parseEnvelope(_result, "records")
+		if parsed.kind == "absent" then
+			return {
+				kind = "ok",
+				value = nil,
+			}
+		end
+		if parsed.kind == "unreadable" then
+			return self:unavailable(key, "unreadable", "is unreadable")
+		end
+		if parsed.envelope.payload == nil then
+			return {
+				kind = "ok",
+				value = nil,
+			}
+		end
+		self:remember(key, envelopeBytes(parsed.envelope))
+		local loaded = loadRecord(self.schema, parsed.envelope.payload, parsed.envelope.schemaVersion)
+		if loaded.kind == "newer" then
+			return self:unavailable(key, "newer", "was written by a newer build")
+		end
+		if loaded.kind == "unreadable" then
+			return self:unavailable(key, "unreadable", `did not load: {loaded.reason}`)
+		end
+		return {
+			kind = "ok",
+			value = loaded.value,
+		}
+	end
+	function RecordStore:update(key, change, id)
+		assertOutsideCallback()
+		self:check(key)
+		local port = self.engine.port
+		local _condition = id
+		if _condition == nil then
+			_condition = newOperationId(port)
+		end
+		local sent = _condition
+		if not (type(sent) == "string") or #sent > OPERATION_ID_MAX_BYTES or createdAt(sent) == nil then
+			error(`{self.schema.name}: an operation id comes from operationId() and is at most {OPERATION_ID_MAX_BYTES} bytes`, 2)
+		end
+		if ageOf(sent, port.wall(), OPERATION_ID_MAX_AGE_SECONDS) ~= "fresh" then
+			return {
+				kind = "expired",
+			}
+		end
+		local decision
+		local input = {
+			schema = self.schema,
+			key = key,
+			id = sent,
+			change = change,
+			wall = port.wall,
+		}
+		local deadline = bootClock() + CALL_DEADLINE_SECONDS
+		local ticket = self.engine.scheduler:submit({
+			store = self.schema.name,
+			key = key,
+			priority = 5,
+			kind = "update",
+			dispatchDeadline = deadline,
+			bytes = self:weigh(key),
+			transform = function()
+				return function(current)
+					return updateRecord(current, input, function(d)
+						decision = d
+						return decision
+					end)
+				end
+			end,
+		})
+		local settled = ticket:wait(deadline) or {
+			kind = if ticket.dispatched then "uncertain" else "timeout",
+		}
+		if settled.kind ~= "done" then
+			return {
+				kind = settled.kind,
+			}
+		end
+		if settled.outcome.kind == "error" or decision == nil then
+			return {
+				kind = "unavailable",
+			}
+		end
+		local _exp = decision.kind
+		repeat
+			if _exp == "refused" then
+				return error(decision.error, 0)
+			end
+			if _exp == "written" then
+				self:remember(key, decision.bytes)
+				return {
+					kind = "ok",
+					value = decision.value,
+					replayed = false,
+				}
+			end
+			if _exp == "replay" then
+				local loaded = loadRecord(self.schema, decision.envelope.payload, decision.envelope.schemaVersion)
+				if loaded.kind ~= "ok" then
+					return {
+						kind = "unavailable",
+					}
+				end
+				return {
+					kind = "ok",
+					value = loaded.value,
+					replayed = true,
+				}
+			end
+			if _exp == "newer" then
+				return self:unavailable(key, "newer", "was written by a newer build")
+			end
+			if _exp == "unreadable" then
+				return self:unavailable(key, "unreadable", `did not load: {decision.reason}`)
+			end
+			if _exp == "too-large" then
+				return self:unavailable(key, "large", `would make the envelope {decision.bytes} bytes`)
+			end
+			return {
+				kind = decision.kind,
+			}
+		until true
+	end
+end
+return {
+	RecordStore = RecordStore,
+}

package/out/internal/data/runtime.d.ts

@@ -0,0 +1 @@
+export {};