LibAcc: 0.6923=63/91, ProjAcc: 1.0000=0/0, Missing: 202
Module: src/lib/Service
const 𝓟1{uuid} = 𝓛10097{require}(𝓛8743{String}).v1;
const 𝓟2{uncommittedEvents} = 𝓛10031{Symbol}.for(𝓛8743{String});
const 𝓟3{setdata} = 𝓛10031{Symbol}.for(𝓛8743{String});
function 𝓟4{CONSTRUCTOR} (𝓟5{actor}: [OOV]𝓟[ty]512{Actor},𝓟6{bus}: [OOV]𝓟[ty]601{EventBus},𝓟7{getActor},𝓟8{createActor},𝓟9{method}: 𝓛[ty]10051{String},𝓟10{sagaId}: 𝓛[ty]10051{String},𝓟11{roleName}: 𝓛[ty]10051{String},𝓟12{role}: [OOV]𝓟[ty]247{Role}): (𝓟[ty]16{Service})
{
const 𝓟[ty]16{Service};
const 𝓟[ty]16{Service};
𝓟[ty]16{Service}.sagaMode ⟵ 𝓛8744{Boolean};
𝓟[ty]16{Service}.key ⟵ 𝓟1{uuid}();
𝓟[ty]16{Service}.applied ⟵ 𝓛8744{Boolean};
𝓟[ty]16{Service}.sagaId ⟵ 𝓟10{sagaId};
𝓟[ty]16{Service}.lockMode ⟵ 𝓛8744{Boolean};
}
class 𝓟[ty]16{Service}{
𝓟18{sagaId}: 𝓛[ty]10051{String};
𝓟19{applied}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8666{Boolean});
𝓟20{sagaMode}: [miss]𝓛[ty]8666{Boolean};
𝓟21{key}: 𝓛[ty]10051{String};
𝓟22{lockMode}: [miss]𝓛[ty]8666{Boolean};
𝓟23{timeout}: 𝓛[ty]8655{Number};
function 𝓟45{actorLock} (𝓟46{actor}): (𝓟47: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8654{Promise}))
{
const 𝓟48{that} = 𝓟[ty]16{Service};
function 𝓟49{$Lambda29} (𝓟50{resolve},𝓟51{reject}): (𝓟52: [miss]𝓛[ty]10033{Void})
{
𝓛1{<UNKNOWN>}()
function 𝓟53{$Async_tryLock} (): (𝓟54: [miss]𝓛[ty]8654{Promise})
{
let 𝓟55{isLock} = 𝓛12547{$Await}(𝓟46{actor}.lock({key: 𝓟48{that}.key,timeout: 𝓟48{that}.timeout}));
if (𝓟55{isLock})
{
𝓟50{resolve}()
}
else
{
𝓛12490{setTimeout}(𝓛1{<UNKNOWN>},𝓛8745{Number})
}
}
}
return 𝓟47 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟49{$Lambda29})
}
function 𝓟65{once} (𝓟66{event}: [OOV]𝓟[ty]1823{EventType},𝓟67{handle}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]10051{String}),𝓟68{timeout}: 𝓛[ty]8655{Number}): (𝓟69: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]16{Service}.bus.subscribe(𝓟66{event},{actorType: 𝓟[ty]16{Service}.actor.type,actorId: 𝓟[ty]16{Service}.actor.id,method: 𝓟67{handle}},𝓟68{timeout})
}
function 𝓟41{sagaEnd} (): (𝓟42: [miss]𝓛[ty]10033{Void})
{
if (𝓟[ty]16{Service}.sagaMode)
{
𝓟[ty]16{Service}.sagaMode ⟵ 𝓛8744{Boolean};
𝓟[ty]16{Service}.sagaId ⟵ 𝓛12563{undefined};
}
}
function 𝓟43{$Async_rollback} (): (𝓟44: [miss]𝓛[ty]8654{Promise})
{
if (𝓟[ty]16{Service}.sagaMode)
{
return 𝓟44 = 𝓛12547{$Await}(𝓟[ty]16{Service}.bus.rollback(𝓟[ty]16{Service}.sagaId))
}
else
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
}
function 𝓟34{lock} (𝓟35{timeout}: 𝓛[ty]8655{Number}): (𝓟36: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]16{Service}.lockMode ⟵ 𝓛8744{Boolean};
𝓟[ty]16{Service}.timeout ⟵ 𝓟35{timeout};
}
function 𝓟37{unlock} (): (𝓟38: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]16{Service}.lockMode ⟵ 𝓛8744{Boolean};
}
function 𝓟61{$Async_create} (𝓟62{type}: 𝓛[ty]10051{String},𝓟63{data}: [OOV]any): (𝓟64: [miss]𝓛[ty]8654{Promise})
{
return 𝓟64 = 𝓟[ty]16{Service}.createActor(𝓛12551{$Spread}(𝓛10035{arguments}),𝓟[ty]16{Service}.sagaId)
}
function 𝓟24{apply} (𝓟25{type}: 𝓛[ty]10051{String},𝓟26{data}: [OOV]any,𝓟27{direct}: 𝓛[ty]8666{Boolean}): (𝓟28: [miss]𝓛[ty]10033{Void})
{
const 𝓟29{event}: [OOV]𝓟[ty]379{Event} = 𝓟359{CONSTRUCTOR}(𝓟[ty]16{Service}.actor,𝓟26{data},𝓟25{type},𝓟[ty]16{Service}.method,𝓟[ty]16{Service}.sagaId,𝓟27{direct}.BarBarToken(𝓛8744{Boolean}),𝓟[ty]16{Service}.roleName);
function 𝓟30{$Lambda28} (): (𝓟31: [miss]𝓛[ty]8642{Object})
{
return 𝓟31 = {isAlive: 𝓛8744{Boolean}}
}
let 𝓟32{updater} = (𝓟25{type}.EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟30{$Lambda28} : 𝓟[ty]16{Service}.actor.updater.access(𝓟25{type}).BarBarToken(𝓟[ty]16{Service}.actor.updater.access(𝓟[ty]16{Service}.method.PlusToken(𝓛8743{String}))).BarBarToken((𝓟[ty]16{Service}.role ? 𝓟[ty]16{Service}.role.updater.access(𝓟25{type}).BarBarToken(𝓟[ty]16{Service}.role.updater.access(𝓟[ty]16{Service}.method)) : 𝓛12563{undefined});
const 𝓟33{updatedData} = 𝓟32{updater}(𝓟[ty]16{Service}.actor.json,𝓟29{event});
𝓟29{event}.updatedData ⟵ 𝓟33{updatedData};
𝓟[ty]16{Service}.actor.access(𝓟3{setdata}) ⟵ 𝓛8741{Object}.assign({},𝓟[ty]16{Service}.actor.json,(𝓟27{direct} ? 𝓟26{data} : {},𝓟33{updatedData});
𝓟[ty]16{Service}.actor.access(𝓟2{uncommittedEvents}) ⟵ 𝓟[ty]16{Service}.actor.access(𝓟2{uncommittedEvents}).BarBarToken(𝓛8757{Array}());
𝓟[ty]16{Service}.actor.access(𝓟2{uncommittedEvents}).push(𝓟29{event})
𝓟[ty]16{Service}.bus.publish(𝓟[ty]16{Service}.actor)
𝓟[ty]16{Service}.applied ⟵ 𝓛8744{Boolean};
}
function 𝓟56{$Async_get} (𝓟57{type}: 𝓛[ty]10051{String},𝓟58{id}: 𝓛[ty]10051{String}): (𝓟59: [miss]𝓛[ty]8654{Promise})
{
if (𝓟58{id}.EqualsEqualsEqualsToken(𝓟[ty]16{Service}.actor.id))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
let 𝓟60{proxy} = 𝓛12547{$Await}(𝓟[ty]16{Service}.getActor(𝓟57{type},𝓟58{id},𝓟[ty]16{Service}.sagaId.BarBarToken(𝓛12563{undefined}),𝓟[ty]16{Service}.key));
if (𝓛12548{ExclamationToken}(𝓟60{proxy}))
{
return 𝓟59 = 𝓛12563{undefined}
}
if (𝓟[ty]16{Service}.lockMode)
{
𝓛12547{$Await}(𝓟[ty]16{Service}.actorLock(𝓟60{proxy}))
}
return 𝓟59 = 𝓟60{proxy}
}
function 𝓟39{sagaBegin} (): (𝓟40: [miss]𝓛[ty]10033{Void})
{
if (𝓟[ty]16{Service}.sagaId.AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟[ty]16{Service}.sagaMode)))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
𝓟[ty]16{Service}.sagaMode ⟵ 𝓛8744{Boolean};
𝓟[ty]16{Service}.sagaId ⟵ 𝓟1{uuid}();
}
}
Module: src/lib/DefaultEventStore
const 𝓟70{nedb} = 𝓛10097{require}(𝓛8743{String});
function 𝓟71{CONSTRUCTOR} (): (𝓟[ty]75{DefaultEventStore})
{
const 𝓟[ty]75{DefaultEventStore};
const 𝓟[ty]75{DefaultEventStore};
𝓟[ty]75{DefaultEventStore}()
𝓟[ty]75{DefaultEventStore}.events ⟵ 𝓟70{nedb}();
𝓟[ty]75{DefaultEventStore}.snaps ⟵ 𝓟70{nedb}();
𝓟[ty]75{DefaultEventStore}.sagas ⟵ 𝓟70{nedb}();
}
class 𝓟[ty]75{DefaultEventStore} extends 𝓛[ty]6152{EventEmitter} with 𝓟[ty]1822{EventStore}{
𝓟77{events};
𝓟78{snaps};
𝓟79{sagas};
function 𝓟132{$Async_getSnapshotByIndex} (𝓟133{actorId},𝓟134{index}): (𝓟135: 𝓛[ty]8654{Promise})
{
let 𝓟136{snap} = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.snaps.cfindOne({actorId: 𝓟133{actorId},index: 𝓟134{index}}).exec());
return 𝓟135 = 𝓟555{parse}(𝓟136{snap})
}
function 𝓟97{$Async_findUndoneSaga} (): (𝓟98: 𝓛[ty]8654{Promise})
{
return 𝓟98 = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.sagas.find({done: 𝓛8744{Boolean}}))
}
function 𝓟113{$Async_getEvents} (𝓟114{actorId}): (𝓟115: [miss]𝓛[ty]8654{Promise})
{
let 𝓟116{events} = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.events.cfind({actorId: 𝓟114{actorId}}).sort({index: 𝓛12557{MinusToken}(𝓛8745{Number}),date: 𝓛12557{MinusToken}(𝓛8745{Number})}).exec());
function 𝓟117{$Lambda3} (𝓟118{event}): (𝓟119: [OOV]𝓟[ty]379{Event})
{
return 𝓟119 = 𝓟374{parse}(𝓟118{event})
}
return 𝓟115 = 𝓛1{<UNKNOWN>}(𝓟117{$Lambda3})
}
function 𝓟152{$Async_removeEventsBySagaId} (𝓟153{sagaId}: 𝓛[ty]10051{String}): (𝓟154: [miss]𝓛[ty]8654{Promise})
{
𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.killSaga(𝓟153{sagaId}))
𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.events.remove({sagaId: 𝓟153{sagaId}}))
}
function 𝓟137{$Async_getSnapshotById} (𝓟138{id}): (𝓟139: [miss]𝓛[ty]8654{Promise})
{
let 𝓟140{snap} = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.snaps.cfindOne({id: 𝓟138{id}}).exec());
return 𝓟139 = 𝓟555{parse}(𝓟140{snap})
}
function 𝓟141{$Async_getEventById} (𝓟142{id}): (𝓟143: [miss]𝓛[ty]8654{Promise})
{
let 𝓟144{event} = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.events.cfindOne({id: 𝓟142{id}}).exec());
if (𝓟144{event})
{
return 𝓟143 = 𝓟374{parse}(𝓟144{event})
}
else
{
return 𝓟143 = 𝓛12563{undefined}
}
}
function 𝓟102{$Async_saveEvents} (𝓟103{events}: [OOV]any): (𝓟104: [miss]𝓛[ty]8654{Promise})
{
𝓟103{events} ⟵ 𝓛8757{Array}().concat(𝓟103{events});
function 𝓟105{$Lambda2} (𝓟106{event}): (𝓟107: [OOV]any)
{
return 𝓟107 = 𝓟106{event}.json.BarBarToken(𝓟106{event})
}
const 𝓟108{eventsJSONArr}: [miss]𝓛[ty]8670{Array} = 𝓛1{<UNKNOWN>}(𝓟105{$Lambda2});
𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.events.insert(𝓟108{eventsJSONArr}))
𝓟[ty]75{DefaultEventStore}.emit(𝓛8743{String},𝓟103{events})
}
function 𝓟109{$Async_getLatestSnapshot} (𝓟110{actorId}): (𝓟111: [miss]𝓛[ty]8654{Promise})
{
let 𝓟112{data} = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.snaps.cfindOne({actorId: 𝓟110{actorId}}).sort({index: 𝓛12557{MinusToken}(𝓛8745{Number}),date: 𝓛12557{MinusToken}(𝓛8745{Number})}).exec());
if (𝓟112{data})
{
return 𝓟111 = 𝓟555{parse}(𝓟112{data})
}
}
function 𝓟87{$Async_getSaga} (𝓟88{sagaId}: 𝓛[ty]10051{String}): (𝓟89: 𝓛[ty]8654{Promise})
{
return 𝓟89 = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.sagas.cfindOne({sagaId: 𝓟88{sagaId},alive: 𝓛8744{Boolean}}).exec())
}
function 𝓟93{$Async_endSaga} (𝓟94{sagaId}): (𝓟95: 𝓛[ty]8654{Promise})
{
const 𝓟96{exist}: [miss]𝓛[ty]8666{Boolean} = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.existSaga(𝓟94{sagaId}));
if (𝓟96{exist})
{
return 𝓟95 = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.sagas.update({sagaId: 𝓟94{sagaId}},{done: 𝓛8744{Boolean}}))
}
}
function 𝓟120{$Async_getLatestEvent} (𝓟121{actorId}): (𝓟122: [miss]𝓛[ty]8654{Promise})
{
let 𝓟123{event} = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.events.cfind({actorId: 𝓟121{actorId}}).sort({index: 𝓛12557{MinusToken}(𝓛8745{Number}),date: 𝓛12557{MinusToken}(𝓛8745{Number})}).limit(𝓛8745{Number}).exec());
return 𝓟122 = (𝓟123{event}.length ? 𝓟374{parse}(𝓟123{event}.access(𝓛8745{Number})) : 𝓛12563{undefined}
}
function 𝓟124{$Async_getEventsBySnapshot} (𝓟125{snapId}: 𝓛[ty]10051{String}): (𝓟126: 𝓛[ty]8654{Promise})
{
const 𝓟127{snap}: [OOV]𝓟[ty]559{Snap} = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.getSnapshotById(𝓟125{snapId}));
if (𝓟127{snap})
{
let 𝓟128{events} = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.events.cfind({actorId: 𝓟127{snap}.actorId,index: {'$gt': 𝓟127{snap}.latestEventIndex}}).sort({date: 𝓛8745{Number},index: 𝓛8745{Number}}).exec());
function 𝓟129{$Lambda4} (𝓟130{event}): (𝓟131: [OOV]𝓟[ty]379{Event})
{
return 𝓟131 = 𝓟374{parse}(𝓟130{event})
}
return 𝓟126 = 𝓛1{<UNKNOWN>}(𝓟129{$Lambda4})
}
}
function 𝓟83{$Async_beginSaga} (𝓟84{sagaId}: 𝓛[ty]10051{String}): (𝓟85: 𝓛[ty]8654{Promise})
{
const 𝓟86{exist}: [miss]𝓛[ty]8666{Boolean} = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.existSaga(𝓟84{sagaId}));
if (𝓛12548{ExclamationToken}(𝓟86{exist}))
{
return 𝓟85 = 𝓟[ty]75{DefaultEventStore}.sagas.insert({sagaId: 𝓟84{sagaId},done: 𝓛8744{Boolean},alive: 𝓛8744{Boolean}})
}
}
function 𝓟80{$Async_existSaga} (𝓟81{sagaId}: 𝓛[ty]10051{String}): (𝓟82: 𝓛[ty]8654{Promise})
{
return 𝓟82 = 𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.getSaga(𝓟81{sagaId}))))
}
function 𝓟99{$Async_createSnap} (𝓟100{snap}: [OOV]𝓟[ty]559{Snap}): (𝓟101: [miss]𝓛[ty]8654{Promise})
{
return 𝓟101 = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.snaps.insert(𝓟100{snap}.json))
}
function 𝓟145{$Async_findEventsBySagaId} (𝓟146{sagaId}): (𝓟147: 𝓛[ty]8654{Promise})
{
let 𝓟148{events} = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.events.cfind({sagaId: 𝓟146{sagaId}}).sort({index: 𝓛12557{MinusToken}(𝓛8745{Number}),date: 𝓛12557{MinusToken}(𝓛8745{Number})}).exec());
function 𝓟149{$Lambda5} (𝓟150{event}): (𝓟151: [OOV]𝓟[ty]379{Event})
{
return 𝓟151 = 𝓟374{parse}(𝓟150{event})
}
return 𝓟147 = 𝓛1{<UNKNOWN>}(𝓟149{$Lambda5})
}
function 𝓟90{$Async_killSaga} (𝓟91{sagaId}: 𝓛[ty]10051{String}): (𝓟92: [miss]𝓛[ty]8654{Promise})
{
return 𝓟92 = 𝓛12547{$Await}(𝓟[ty]75{DefaultEventStore}.sagas.update({sagaId: 𝓟91{sagaId}},{alive: 𝓛8744{Boolean}}))
}
}
Module: src/lib/eventAlias
function 𝓟155{getAlias} (𝓟156{event}: [OOV]any): (𝓟157: [OOV]any)
{
if (𝓟156{event}.InstanceOfKeyword(𝓛11626{Event}))
{
return 𝓟157 = 𝓛8757{Array}(𝓛12554{$Template}(𝓟156{event}.actorType,𝓟156{event}.actorId,𝓟156{event}.type,𝓟156{event}.method,𝓟156{event}.sagaId),𝓛12554{$Template}(𝓟156{event}.actorType,𝓟156{event}.actorId,𝓟156{event}.type,𝓟156{event}.method),𝓛12554{$Template}(𝓟156{event}.actorType,𝓟156{event}.actorId,𝓟156{event}.type),𝓛12554{$Template}(𝓟156{event}.actorType,𝓟156{event}.actorId),𝓛12554{$Template}(𝓟156{event}.actorType,𝓟156{event}.type),𝓛12554{$Template}(𝓟156{event}.type),𝓛12554{$Template}(𝓟156{event}.actorType),𝓛8743{String})
}
else
{
return 𝓟157 = 𝓛12554{$Template}(𝓟156{event}.actorType.BarBarToken(𝓛8743{String}),𝓟156{event}.actorId.BarBarToken(𝓛8743{String}),𝓟156{event}.type.BarBarToken(𝓛8743{String}),𝓟156{event}.method.BarBarToken(𝓛8743{String}),𝓟156{event}.sagaId.BarBarToken(𝓛8743{String}))
}
}
Module: src/lib/EventStore
type 𝓟[ty]1822{EventStore} = {existSaga: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, removeEventsBySagaId: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, once: (any,any)->𝓛[ty]10033{Void}, getSaga: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, getSnapshotById: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, saveEvents: (any)->𝓛[ty]8654{Promise}, getSnapshotByIndex: (𝓛[ty]10051{String},𝓛[ty]8655{Number})->𝓛[ty]8654{Promise}, killSaga: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, on: (any,any)->𝓛[ty]10033{Void}, createSnap: (any)->𝓛[ty]8654{Promise}, getEventById: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, beginSaga: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, findUndoneSaga: ()->𝓛[ty]8654{Promise}, getEventsBySnapshot: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, getEvents: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, endSaga: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, getLatestSnapshot: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, findEventsBySagaId: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, getLatestEvent: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}}
Module: src/lib/excludeMethods
const 𝓟159{defaultVar}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String});
Module: src/lib/Repository
const 𝓟160{setdata} = 𝓛10031{Symbol}.for(𝓛8743{String});
function 𝓟161{CONSTRUCTOR} (𝓟162{ActorClass}: [OOV]𝓟[ty]1816{ActorConstructor},𝓟163{eventstore}: [OOV]𝓟[ty]75{DefaultEventStore},𝓟164{roleMap}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]3199{Map})): (𝓟[ty]168{Repository})
{
const 𝓟[ty]168{Repository};
const 𝓟[ty]168{Repository};
𝓟[ty]168{Repository}.cache ⟵ 𝓛2995{Map}.CONSTRUCTOR();
𝓟[ty]168{Repository}()
}
class 𝓟[ty]168{Repository} extends 𝓛[ty]6152{EventEmitter}{
𝓟170{cache}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]3199{Map});
function 𝓟205{getCacheActorIds} (): (𝓟206: [miss]𝓛[ty]8670{Array})
{
return 𝓟206 = 𝓛8757{Array}(𝓛12551{$Spread}(𝓟[ty]168{Repository}.cache.keys()))
}
function 𝓟202{exist} (𝓟203{id}): (𝓟204: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟204 = 𝓟[ty]168{Repository}.cache.has(𝓟203{id})
}
function 𝓟178{clear} (𝓟179{id}): (𝓟180: [miss]𝓛[ty]10033{Void})
{
if (𝓟[ty]168{Repository}.cache.has(𝓟179{id}))
{
𝓟[ty]168{Repository}.cache.delete(𝓟179{id})
𝓟[ty]168{Repository}.emit(𝓛8743{String},𝓟179{id})
}
}
function 𝓟181{getFromCache} (𝓟182{id}): (𝓟183: [OOV]𝓟[ty]512{Actor})
{
return 𝓟183 = 𝓟[ty]168{Repository}.cache.get(𝓟182{id})
}
function 𝓟184{$Async_getHistory} (𝓟185{actorId}: 𝓛[ty]10051{String}): (𝓟186: [miss]𝓛[ty]8654{Promise})
{
const 𝓟187{snap}: [OOV]𝓟[ty]559{Snap} = 𝓛12547{$Await}(𝓟[ty]168{Repository}.eventstore.getSnapshotByIndex(𝓟185{actorId},𝓛8745{Number}));
const 𝓟188{events} = 𝓛12547{$Await}(𝓟[ty]168{Repository}.eventstore.getEvents(𝓟185{actorId}));
if (𝓟187{snap})
{
return 𝓟186 = {_index: 𝓛1{<UNKNOWN>},_events: 𝓟188{events},_snap: 𝓟187{snap},data: 𝓟658{reborm}(𝓟[ty]168{Repository}.ActorClass,𝓟187{snap},𝓟188{events}).json,done: 𝓛8744{Boolean}}
}
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}.PlusToken(𝓟185{actorId}))
}
function 𝓟171{$Async_create} (𝓟172{data}: [OOV]any): (𝓟173: 𝓛[ty]8654{Promise})
{
const 𝓟174{actor}: [OOV]𝓟[ty]512{Actor} = 𝓟[ty]168{Repository}.ActorClass.CONSTRUCTOR(𝓟172{data});
const 𝓟175{snap}: [OOV]𝓟[ty]559{Snap} = 𝓟548{CONSTRUCTOR}(𝓟174{actor});
𝓛12547{$Await}(𝓟[ty]168{Repository}.eventstore.createSnap(𝓟175{snap}))
𝓟[ty]168{Repository}.cache.set(𝓟174{actor}.id,𝓟174{actor})
function 𝓟176{$Lambda26} (): (𝓟177: [OOV]any)
{
return 𝓟177 = 𝓟[ty]168{Repository}.emit(𝓛8743{String},𝓟174{actor}.json)
}
𝓛10082{setImmediate}(𝓟176{$Lambda26})
return 𝓟173 = 𝓟174{actor}
}
function 𝓟189{$Async_get} (𝓟190{id}): (𝓟191: 𝓛[ty]8654{Promise})
{
let 𝓟192{actor}: [OOV]𝓟[ty]512{Actor} = 𝓟[ty]168{Repository}.getFromCache(𝓟190{id});
if (𝓟192{actor})
{
if (𝓟192{actor}.json.isAlive)
{
return 𝓟191 = 𝓟192{actor}
}
else
{
𝓟[ty]168{Repository}.cache.delete(𝓟190{id})
return 𝓟191 = 𝓛12563{undefined}
}
}
else
{
𝓟[ty]168{Repository}.emit(𝓛8743{String},𝓟190{id})
let 𝓟193{snap}: [OOV]𝓟[ty]559{Snap} = 𝓛12547{$Await}(𝓟[ty]168{Repository}.eventstore.getLatestSnapshot(𝓟190{id}));
if (𝓟193{snap})
{
const 𝓟194{events} = 𝓛12547{$Await}(𝓟[ty]168{Repository}.eventstore.getEventsBySnapshot(𝓟193{snap}.id));
const 𝓟195{actor}: [OOV]𝓟[ty]512{Actor} = 𝓟[ty]168{Repository}.ActorClass.parse(𝓟193{snap}.data);
function 𝓟196{$Lambda27} (𝓟197{event}): (𝓟198: [OOV]𝓟[ty]512{Actor})
{
let 𝓟199{role}: [OOV]𝓟[ty]247{Role} = 𝓟[ty]168{Repository}.roleMap.get(𝓟197{event}.roleName);
let 𝓟200{updater} = 𝓟195{actor}.updater.access(𝓟197{event}.type).BarBarToken(𝓟195{actor}.updater.access(𝓟197{event}.method.PlusToken(𝓛8743{String}))).BarBarToken((𝓟199{role} ? 𝓟199{role}.updater.access(𝓟197{event}.type).BarBarToken(𝓟199{role}.updater.access(𝓟197{event}.method)) : 𝓛12563{undefined});
const 𝓟201{updatedData} = (𝓟200{updater} ? 𝓟200{updater}(𝓟195{actor}.json,𝓟197{event}) : {};
𝓟195{actor}.access(𝓟160{setdata}) ⟵ 𝓛8741{Object}.assign({},𝓟195{actor}.json,𝓟201{updatedData});
return 𝓟198 = 𝓟195{actor}.BarBarToken(𝓛12563{undefined})
}
𝓛1{<UNKNOWN>}(𝓟196{$Lambda27})
}
}
}
}
Module: src/lib/DomainServer
const 𝓟207{getActorProxy} = 𝓛10031{Symbol}.for(𝓛8743{String});
function 𝓟208{CONSTRUCTOR} (𝓟209{domain}: [OOV]𝓟[ty]412{Domain},𝓟210{port}: 𝓛[ty]8655{Number}): (𝓟[ty]237{DomainServer})
{
const 𝓟[ty]237{DomainServer};
const 𝓟[ty]237{DomainServer};
const 𝓟214{io} = 𝓛12563{undefined}();
function 𝓟215{$Lambda13} (𝓟216{socket}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟217: [miss]𝓛[ty]10033{Void})
{
function 𝓟218{$Async_$Lambda14} (𝓟219{type},𝓟220{id},𝓟221{sagaId},𝓟222{key},𝓟223{methodName},𝓟224{args},𝓟225{callback}): (𝓟226: [miss]𝓛[ty]8654{Promise})
{
let 𝓟227{actor} = 𝓛12547{$Await}(𝓛1{<UNKNOWN>}(𝓟207{getActorProxy})(𝓟219{type},𝓟220{id},𝓟221{sagaId},𝓟222{key}));
if (𝓟227{actor})
{
{
let 𝓟228{result} = 𝓛12547{$Await}(𝓟227{actor}.access(𝓟223{methodName})(𝓛12551{$Spread}(𝓟224{args})));
𝓟225{callback}(𝓛12563{undefined},𝓟228{result})
}
}
else
{
𝓟225{callback}(𝓛8743{String}.PlusToken(𝓟220{id}))
}
}
𝓟216{socket}.on(𝓛8743{String},𝓛1{<UNKNOWN>})
function 𝓟229{$Lambda15} (𝓟230{type},𝓟231{id},𝓟232{callback}): (𝓟233: [miss]𝓛[ty]10033{Void})
{
function 𝓟234{$Lambda16} (𝓟235{actor}): (𝓟236: [miss]𝓛[ty]10033{Void})
{
𝓟232{callback}(𝓟235{actor}.json)
}
𝓛1{<UNKNOWN>}(𝓟230{type},𝓟231{id}).then(𝓟234{$Lambda16})
}
𝓟216{socket}.on(𝓛8743{String},𝓟229{$Lambda15})
}
𝓟214{io}.on(𝓛8743{String},𝓟215{$Lambda13})
𝓟214{io}.listen(𝓟210{port})
}
class 𝓟[ty]237{DomainServer}{
}
Module: src/lib/DomainProxy
const 𝓟257{uid} = 𝓛10097{require}(𝓛8743{String}).v1;
function 𝓟258{CONSTRUCTOR} (𝓟259{manager}: [OOV]𝓟[ty]325{DefaultCluterInfoManager},𝓟260{ActorClassMap}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]3199{Map})): (𝓟[ty]266{DomainProxy})
{
const 𝓟[ty]266{DomainProxy};
const 𝓟[ty]266{DomainProxy};
𝓟[ty]266{DomainProxy}.domainInfos ⟵ 𝓛2995{Map}.CONSTRUCTOR();
𝓟[ty]266{DomainProxy}.sockets ⟵ {};
𝓟[ty]266{DomainProxy}()
function 𝓟264{$Lambda8} (): (𝓟265: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]266{DomainProxy}.emit(𝓛8743{String})
}
𝓟[ty]266{DomainProxy}.refreshDomainInfo().then(𝓟264{$Lambda8})
}
class 𝓟[ty]266{DomainProxy} extends 𝓛[ty]6152{EventEmitter}{
𝓟268{domainInfos}: [miss]𝓛[ty]3199{Map};
𝓟269{sockets}: [miss]𝓛[ty]8642{Object};
function 𝓟270{$Async_refreshDomainInfo} (): (𝓟271: [miss]𝓛[ty]8654{Promise})
{
const 𝓟272{infos} = 𝓛12547{$Await}(𝓟[ty]266{DomainProxy}.manager.getAllDomainInfo());
{
let 𝓟273{info} = 𝓛12552{$ArrayAccess}(𝓟272{infos});
while (𝓛8744{Boolean})
{
𝓟[ty]266{DomainProxy}.domainInfos.set(𝓟273{info}.id,𝓟273{info})
}
}
}
function 𝓟274{$Async_createSocket} (𝓟275{domainInfo}): (𝓟276: [miss]𝓛[ty]8654{Promise})
{
const 𝓟277{that} = 𝓟[ty]266{DomainProxy};
function 𝓟278{$Lambda9} (𝓟279{resolve}): (𝓟280: [miss]𝓛[ty]10033{Void})
{
const 𝓟281{socket} = 𝓛12563{undefined}(𝓟275{domainInfo}.url);
function 𝓟282{$Lambda10} (): (𝓟283: [miss]𝓛[ty]10033{Void})
{
𝓟277{that}.sockets.access(𝓟275{domainInfo}.id) ⟵ 𝓟281{socket};
𝓟279{resolve}(𝓟281{socket})
}
𝓟281{socket}.on(𝓛8743{String},𝓟282{$Lambda10})
}
return 𝓟276 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟278{$Lambda9})
}
function 𝓟284{addSocket} (𝓟285{domainId},𝓟286{socket}): (𝓟287: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]266{DomainProxy}.sockets.access(𝓟285{domainId}) ⟵ 𝓟286{socket};
}
function 𝓟288{$Async_getActor} (𝓟289{type},𝓟290{id},𝓟291{sagaId},𝓟292{key}): (𝓟293: [miss]𝓛[ty]8654{Promise})
{
const 𝓟294{that} = 𝓟[ty]266{DomainProxy};
const 𝓟295{domainId}: [miss]𝓛[ty]10051{String} = 𝓛12547{$Await}(𝓟[ty]266{DomainProxy}.manager.getDomainIdById(𝓟290{id}));
let 𝓟296{socket} = 𝓟[ty]266{DomainProxy}.sockets.access(𝓟295{domainId});
if (𝓛12548{ExclamationToken}(𝓟296{socket}))
{
let 𝓟297{domainInfo} = 𝓟[ty]266{DomainProxy}.domainInfos.get(𝓟295{domainId}).BarBarToken(𝓛12547{$Await}(𝓟[ty]266{DomainProxy}.refreshDomainInfo()).BarBarToken(𝓟[ty]266{DomainProxy}.domainInfos.get(𝓟295{domainId})));
if (𝓛12548{ExclamationToken}(𝓟297{domainInfo}))
{
return 𝓟293 = 𝓛12563{undefined}
}
𝓟296{socket} ⟵ 𝓛12547{$Await}(𝓟[ty]266{DomainProxy}.createSocket(𝓟297{domainInfo}));
}
function 𝓟298{$Lambda11} (𝓟299{resolve},𝓟300{reject}): (𝓟301: [miss]𝓛[ty]10033{Void})
{
function 𝓟302{$Lambda12} (𝓟303{actorInfo}): (𝓟304: [miss]𝓛[ty]10033{Void})
{
if (𝓟303{actorInfo})
{
const 𝓟305{proxy} = 𝓛10041{Proxy}.CONSTRUCTOR(𝓟303{actorInfo},{});
𝓟299{resolve}(𝓟305{proxy})
}
else
{
𝓟299{resolve}(𝓛12563{undefined})
}
}
𝓟296{socket}.emit(𝓛8743{String},𝓟289{type},𝓟290{id},𝓟302{$Lambda12})
}
return 𝓟293 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟298{$Lambda11})
}
}
Module: src/lib/DefaultClusterInfoManager
const 𝓟306{METHODS}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String});
function 𝓟307{CONSTRUCTOR} (𝓟308{port}: [OOV]any): (𝓟[ty]325{DefaultCluterInfoManager})
{
const 𝓟[ty]325{DefaultCluterInfoManager};
const 𝓟[ty]325{DefaultCluterInfoManager};
𝓟[ty]325{DefaultCluterInfoManager}.domainInfoMap ⟵ 𝓛2995{Map}.CONSTRUCTOR();
𝓟[ty]325{DefaultCluterInfoManager}.idMap ⟵ 𝓛2995{Map}.CONSTRUCTOR();
if (𝓛12550{$TypeOf}(𝓟308{port}).EqualsEqualsEqualsToken(𝓛8743{String}))
{
const 𝓟312{socket} = 𝓛12563{undefined}(𝓟308{port});
return 𝓟[ty]325{DefaultCluterInfoManager} = 𝓛10041{Proxy}.CONSTRUCTOR(𝓟[ty]325{DefaultCluterInfoManager},{})
}
𝓟[ty]325{DefaultCluterInfoManager}.server ⟵ 𝓛12563{undefined}();
𝓟[ty]325{DefaultCluterInfoManager}.server.listen(𝓟308{port})
function 𝓟313{$Lambda0} (𝓟314{socket}): (𝓟315: [miss]𝓛[ty]10033{Void})
{
function 𝓟316{$Async_$Lambda1} (𝓟317{args}): (𝓟318: [miss]𝓛[ty]8654{Promise})
{
const 𝓟319{callback} = 𝓟317{args}.pop();
const 𝓟320{methodName} = 𝓟317{args}.shift();
const 𝓟321{result} = 𝓛12547{$Await}(𝓟[ty]325{DefaultCluterInfoManager}.access(𝓟320{methodName})(𝓛12551{$Spread}(𝓟317{args})));
if (𝓟320{methodName}.EqualsEqualsEqualsToken(𝓛8743{String}))
{
let 𝓟322{json}: [miss]𝓛[ty]8642{Object} = {};
{
let 𝓟323{domainId} = 𝓛12552{$ArrayAccess}(𝓛12552{$ArrayAccess}(𝓟321{result}));
let 𝓟324{set} = 𝓛12552{$ArrayAccess}(𝓛12552{$ArrayAccess}(𝓟321{result}));
while (𝓛8744{Boolean})
{
𝓟322{json}.access(𝓟323{domainId}) ⟵ 𝓛8757{Array}(𝓛12551{$Spread}(𝓟324{set}));
}
}
return 𝓟318 = 𝓟319{callback}(𝓛12563{undefined},𝓟322{json})
}
𝓟319{callback}(𝓛12563{undefined},𝓟321{result})
}
𝓟314{socket}.on(𝓛8743{String},𝓛1{<UNKNOWN>})
}
𝓟[ty]325{DefaultCluterInfoManager}.server.on(𝓛8743{String},𝓟313{$Lambda0})
}
class 𝓟[ty]325{DefaultCluterInfoManager}{
𝓟327{domainInfoMap}: [miss]𝓛[ty]3199{Map};
𝓟328{idMap}: [miss]𝓛[ty]3199{Map};
𝓟329{server};
function 𝓟343{$Async_getDomainIdById} (𝓟344{id}): (𝓟345: [miss]𝓛[ty]8654{Promise})
{
{
let 𝓟346{domainId}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓛12552{$ArrayAccess}(𝓟[ty]325{DefaultCluterInfoManager}.idMap));
let 𝓟347{idset}: [miss]𝓛[ty]5956{Set} = 𝓛12552{$ArrayAccess}(𝓛12552{$ArrayAccess}(𝓟[ty]325{DefaultCluterInfoManager}.idMap));
while (𝓛8744{Boolean})
{
if (𝓟347{idset}.has(𝓟344{id}))
{
return 𝓟345 = 𝓟346{domainId}
}
}
}
}
function 𝓟348{$Async_addId} (𝓟349{domainId},𝓟350{id}): (𝓟351: [miss]𝓛[ty]8654{Promise})
{
const 𝓟352{did}: [miss]𝓛[ty]10051{String} = 𝓛12547{$Await}(𝓟[ty]325{DefaultCluterInfoManager}.getDomainIdById(𝓟350{id}));
if (𝓟352{did})
{
{code: 𝓛8743{String},id: 𝓟350{id},domainId: 𝓟352{did}}
}
const 𝓟353{set}: [miss]𝓛[ty]5956{Set} = 𝓟[ty]325{DefaultCluterInfoManager}.idMap.get(𝓟349{domainId});
if (𝓟353{set})
{
𝓟353{set}.add(𝓟350{id})
}
}
function 𝓟354{$Async_getIdMap} (): (𝓟355: [miss]𝓛[ty]8654{Promise})
{
return 𝓟355 = 𝓟[ty]325{DefaultCluterInfoManager}.idMap
}
function 𝓟332{$Async_register} (𝓟333{domainInfo}): (𝓟334: [miss]𝓛[ty]8654{Promise})
{
𝓟[ty]325{DefaultCluterInfoManager}.domainInfoMap.set(𝓟333{domainInfo}.id,𝓟333{domainInfo})
𝓟[ty]325{DefaultCluterInfoManager}.idMap.set(𝓟333{domainInfo}.id,𝓛2997{Set}.CONSTRUCTOR())
}
function 𝓟335{$Async_logout} (𝓟336{domainId}): (𝓟337: [miss]𝓛[ty]8654{Promise})
{
𝓟[ty]325{DefaultCluterInfoManager}.domainInfoMap.delete(𝓟336{domainId})
𝓟[ty]325{DefaultCluterInfoManager}.idMap.delete(𝓟336{domainId})
}
function 𝓟338{$Async_deleteID} (𝓟339{id}): (𝓟340: [miss]𝓛[ty]8654{Promise})
{
{
let 𝓟341{domainId}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓛12552{$ArrayAccess}(𝓟[ty]325{DefaultCluterInfoManager}.idMap));
let 𝓟342{idset}: [miss]𝓛[ty]5956{Set} = 𝓛12552{$ArrayAccess}(𝓛12552{$ArrayAccess}(𝓟[ty]325{DefaultCluterInfoManager}.idMap));
while (𝓛8744{Boolean})
{
𝓟342{idset}.delete(𝓟339{id})
}
}
}
function 𝓟330{$Async_getAllDomainInfo} (): (𝓟331: 𝓛[ty]8654{Promise})
{
return 𝓟331 = 𝓛8757{Array}(𝓛12551{$Spread}(𝓟[ty]325{DefaultCluterInfoManager}.domainInfoMap.values()))
}
}
Module: src/lib/EventType
type 𝓟[ty]1823{EventType} = {method: 𝓛[ty]10051{String}, sagaId: 𝓛[ty]10051{String}, data: any, actorId: 𝓛[ty]10051{String}, actorType: 𝓛[ty]10051{String}, type: 𝓛[ty]10051{String}}
Module: src/lib/types/LockDataType
type 𝓟[ty]1812{LockDataType} = {key: 𝓛[ty]10051{String}, timeout: 𝓛[ty]8655{Number}}
Module: src/lib/Domain
const 𝓟403{isLock} = 𝓛10031{Symbol}.for(𝓛8743{String});
const 𝓟404{debug} = 𝓛10097{require}(𝓛8743{String})(𝓛8743{String});
const 𝓟405{uid} = 𝓛10097{require}(𝓛8743{String}).v1;
const 𝓟406{getActorProxy} = 𝓛10031{Symbol}.for(𝓛8743{String});
function 𝓟407{CONSTRUCTOR} (𝓟408{options}: [OOV]any): (𝓟[ty]412{Domain})
{
const 𝓟[ty]412{Domain};
const 𝓟[ty]412{Domain};
𝓟[ty]412{Domain}.roleMap ⟵ 𝓛2995{Map}.CONSTRUCTOR();
𝓟[ty]412{Domain}.id ⟵ 𝓟405{uid}();
𝓟[ty]412{Domain}.ActorClassMap ⟵ 𝓛2995{Map}.CONSTRUCTOR();
if (𝓟408{options}.domainServerUrl.AmpersandAmpersandToken(𝓟408{options}.domainServerPort).AmpersandAmpersandToken(𝓟408{options}.clusterUrl.BarBarToken(𝓟408{options}.clusterPort)))
{
𝓟[ty]412{Domain}.clusterInfoManager ⟵ 𝓟307{CONSTRUCTOR}(𝓟408{options}.clusterUrl.BarBarToken(𝓟408{options}.clusterPort));
𝓟[ty]412{Domain}.clusterInfoManager.register({id: 𝓟[ty]412{Domain}.id,url: 𝓟408{options}.domainServerUrl})
𝓟[ty]412{Domain}.domainServer ⟵ 𝓟208{CONSTRUCTOR}(𝓟[ty]412{Domain},𝓟408{options}.domainServerPort);
𝓟[ty]412{Domain}.domainProxy ⟵ 𝓟258{CONSTRUCTOR}(𝓟[ty]412{Domain}.clusterInfoManager,𝓟[ty]412{Domain}.ActorClassMap);
}
𝓟[ty]412{Domain}.eventstore ⟵ 𝓟408{options}.eventstore.BarBarToken((𝓟408{options}.EventStore ? 𝓟408{options}.EventStore.CONSTRUCTOR() : 𝓟71{CONSTRUCTOR}());
𝓟[ty]412{Domain}.repositorieMap ⟵ 𝓛2995{Map}.CONSTRUCTOR();
𝓟[ty]412{Domain}.eventbus ⟵ (𝓟408{options}.EventBus ? 𝓟408{options}.EventBus.CONSTRUCTOR(𝓟[ty]412{Domain}.eventstore,𝓟[ty]412{Domain},𝓟[ty]412{Domain}.repositorieMap,𝓟[ty]412{Domain}.ActorClassMap) : 𝓟580{CONSTRUCTOR}(𝓟[ty]412{Domain}.eventstore,𝓟[ty]412{Domain},𝓟[ty]412{Domain}.repositorieMap,𝓟[ty]412{Domain}.ActorClassMap);
}
class 𝓟[ty]412{Domain}{
𝓟414{domainProxy}: [OOV]𝓟[ty]266{DomainProxy};
𝓟415{domainServer}: [OOV]𝓟[ty]237{DomainServer};
𝓟416{eventbus}: [OOV]𝓟[ty]601{EventBus};
𝓟417{eventstore}: [OOV]𝓟[ty]75{DefaultEventStore};
𝓟418{repositorieMap}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]3199{Map});
𝓟419{id};
𝓟420{clusterInfoManager}: [OOV]𝓟[ty]325{DefaultCluterInfoManager};
𝓟421{roleMap}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]3199{Map});
𝓟422{ActorClassMap}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]3199{Map});
function 𝓟482{getCacheActorIds} (): (𝓟483: [miss]𝓛[ty]8670{Array})
{
let 𝓟484{result}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
{
let 𝓟485{key}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓛12552{$ArrayAccess}(𝓟[ty]412{Domain}.ActorClassMap));
let 𝓟486{Actor}: [OOV]𝓟[ty]1816{ActorConstructor} = 𝓛12552{$ArrayAccess}(𝓛12552{$ArrayAccess}(𝓟[ty]412{Domain}.ActorClassMap));
while (𝓛8744{Boolean})
{
𝓟484{result} ⟵ 𝓟484{result}.concat(𝓟[ty]412{Domain}.repositorieMap.get(𝓟486{Actor}).getCacheActorIds());
}
}
return 𝓟483 = 𝓟484{result}
}
function 𝓟452{register} (𝓟453{Classes}: [OOV]any): (𝓟454: [OOV]any)
{
if (𝓛12548{ExclamationToken}(𝓛8757{Array}.isArray(𝓟453{Classes})))
{
𝓟453{Classes} ⟵ 𝓛8757{Array}(𝓟453{Classes});
}
{
let 𝓟455{Class}: [OOV]𝓟[ty]1816{ActorConstructor} = 𝓛12552{$ArrayAccess}(𝓟453{Classes});
while (𝓛8744{Boolean})
{
𝓟[ty]412{Domain}.ActorClassMap.set(𝓟455{Class}.getType(),𝓟455{Class})
const 𝓟456{repo}: [OOV]𝓟[ty]168{Repository} = 𝓟161{CONSTRUCTOR}(𝓟455{Class},𝓟[ty]412{Domain}.eventstore,𝓟[ty]412{Domain}.roleMap);
if (𝓟[ty]412{Domain}.clusterInfoManager)
{
function 𝓟457{$Async_$Lambda6} (𝓟458{actorJSON}): (𝓟459: [miss]𝓛[ty]8654{Promise})
{
𝓛12547{$Await}(𝓟[ty]412{Domain}.clusterInfoManager.addId(𝓟[ty]412{Domain}.id,𝓟458{actorJSON}.id))
}
𝓟456{repo}.on(𝓛8743{String},𝓛1{<UNKNOWN>})
}
function 𝓟460{$Lambda7} (𝓟461{json}): (𝓟462: [miss]𝓛[ty]10033{Void})
{
let 𝓟463{event}: [OOV]𝓟[ty]379{Event} = 𝓟359{CONSTRUCTOR}({id: 𝓟461{json}.id,type: 𝓟455{Class}.getType()},𝓟461{json},𝓛8743{String},𝓛8743{String});
const 𝓟464{alias} = 𝓟155{getAlias}(𝓟463{event});
{
let 𝓟465{name} = 𝓛12552{$ArrayAccess}(𝓟464{alias});
while (𝓛8744{Boolean})
{
𝓟[ty]412{Domain}.eventbus.emitter.emit(𝓟465{name},𝓟463{event})
}
}
}
𝓟456{repo}.on(𝓛8743{String},𝓟460{$Lambda7})
𝓟[ty]412{Domain}.repositorieMap.set(𝓟455{Class},𝓟456{repo})
}
}
return 𝓟454 = 𝓟[ty]412{Domain}
}
function 𝓟478{once} (𝓟479{event},𝓟480{handle}): (𝓟481: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]412{Domain}.eventbus.on(𝓟479{event},𝓟480{handle})
}
function 𝓟433{$Async_nativeCreateActor} (𝓟434{type},𝓟435{data}): (𝓟436: [miss]𝓛[ty]8654{Promise})
{
const 𝓟437{actorType} = 𝓟434{type}.split(𝓛8743{String}).shift();
const 𝓟438{ActorClass}: [OOV]𝓟[ty]1816{ActorConstructor} = 𝓟[ty]412{Domain}.ActorClassMap.get(𝓟437{actorType});
const 𝓟439{repo}: [OOV]𝓟[ty]168{Repository} = 𝓟[ty]412{Domain}.repositorieMap.get(𝓟438{ActorClass});
if (𝓟438{ActorClass}.createBefor)
{
{
𝓟435{data} ⟵ 𝓛12547{$Await}(𝓟438{ActorClass}.createBefor(𝓟435{data},𝓟[ty]412{Domain})).BarBarToken(𝓟435{data});
}
}
const 𝓟440{actorId} = 𝓛12547{$Await}(𝓟439{repo}.create(𝓟435{data})).json.id;
const 𝓟441{actor} = 𝓛12547{$Await}(𝓟[ty]412{Domain}.access(𝓟406{getActorProxy})(𝓟434{type},𝓟440{actorId}));
return 𝓟436 = 𝓟441{actor}
}
function 𝓟442{$Async_$ComputedPropertyName} (𝓟443{type}: 𝓛[ty]10051{String},𝓟444{id}: 𝓛[ty]10051{String},𝓟445{sagaId}: 𝓛[ty]10051{String},𝓟446{key}: 𝓛[ty]10051{String}): (𝓟447: [miss]𝓛[ty]8654{Promise})
{
const 𝓟448{that} = 𝓟[ty]412{Domain};
let 𝓟449{actor} = 𝓛12547{$Await}(𝓟[ty]412{Domain}.getNativeActor(𝓟443{type},𝓟444{id}));
if (𝓛12548{ExclamationToken}(𝓟449{actor}))
{
if (𝓟[ty]412{Domain}.domainProxy)
{
return 𝓟447 = 𝓛12547{$Await}(𝓟[ty]412{Domain}.domainProxy.getActor(𝓟443{type},𝓟444{id},𝓟445{sagaId},𝓟446{key}))
}
else
{
return 𝓟447 = 𝓛12563{undefined}
}
}
let 𝓟450{roles};
if (𝓛8757{Array}.isArray(𝓟449{actor}))
{
𝓟450{roles} ⟵ 𝓟449{actor}.access(𝓛8745{Number});
𝓟449{actor} ⟵ 𝓟449{actor}.access(𝓛8745{Number});
}
const 𝓟451{proxy} = 𝓛10041{Proxy}.CONSTRUCTOR(𝓟449{actor},{});
return 𝓟447 = 𝓟451{proxy}
}
function 𝓟466{$Async_create} (𝓟467{type}: 𝓛[ty]10051{String},𝓟468{data}: [OOV]any): (𝓟469: [miss]𝓛[ty]8654{Promise})
{
return 𝓟469 = 𝓛12547{$Await}(𝓟[ty]412{Domain}.nativeCreateActor(𝓟467{type},𝓟468{data}))
}
function 𝓟474{on} (𝓟475{event},𝓟476{handle}): (𝓟477: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]412{Domain}.eventbus.on(𝓟475{event},𝓟476{handle})
}
function 𝓟470{$Async_get} (𝓟471{type}: 𝓛[ty]10051{String},𝓟472{id}: 𝓛[ty]10051{String}): (𝓟473: [miss]𝓛[ty]8654{Promise})
{
return 𝓟473 = 𝓛12547{$Await}(𝓟[ty]412{Domain}.access(𝓟406{getActorProxy})(𝓟471{type},𝓟472{id}))
}
function 𝓟487{addRole} (𝓟488{name}: [OOV]any,𝓟489{supportedActorNames}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟490{methods}: [OOV]any,𝓟491{updater}: [OOV]any): (𝓟492: [OOV]any)
{
if (𝓛12550{$TypeOf}(𝓟488{name}).ExclamationEqualsEqualsToken(𝓛8743{String}))
{
𝓟489{supportedActorNames} ⟵ 𝓟488{name}.types;
𝓟490{methods} ⟵ 𝓟488{name}.methods;
𝓟491{updater} ⟵ 𝓟488{name}.updater;
𝓟488{name} ⟵ 𝓟488{name}.name;
}
if (𝓟[ty]412{Domain}.roleMap.has(𝓟488{name}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓟488{name}.PlusToken(𝓛8743{String}))
}
𝓟[ty]412{Domain}.roleMap.set(𝓟488{name},𝓟239{CONSTRUCTOR}(𝓟488{name},𝓟489{supportedActorNames},𝓟490{methods},𝓟491{updater}))
return 𝓟492 = 𝓟[ty]412{Domain}
}
function 𝓟423{$Async_getNativeActor} (𝓟424{type}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]10051{String}),𝓟425{id}: 𝓛[ty]10051{String}): (𝓟426: 𝓛[ty]8654{Promise})
{
const 𝓟427{roles}: [miss]𝓛[ty]8670{Array} = 𝓟424{type}.split(𝓛8743{String});
const 𝓟428{actorType}: [miss]𝓛[ty]10051{String} = 𝓟427{roles}.shift();
let 𝓟429{repo}: [OOV]𝓟[ty]168{Repository} = 𝓟[ty]412{Domain}.repositorieMap.get(𝓟[ty]412{Domain}.ActorClassMap.get(𝓟428{actorType}));
const 𝓟430{actor}: [OOV]𝓟[ty]512{Actor} = 𝓛12547{$Await}(𝓟429{repo}.get(𝓟425{id}));
let 𝓟431{result};
if (𝓟427{roles}.length)
{
{
let 𝓟432{role}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓟427{roles});
while (𝓛8744{Boolean})
{
𝓟431{result} ⟵ 𝓟[ty]412{Domain}.roleMap.get(𝓟432{role}).wrap(𝓟431{result}.BarBarToken(𝓟430{actor}));
}
}
}
return 𝓟426 = 𝓟431{result}.BarBarToken(𝓟430{actor})
}
}
Module: src/lib/Actor
type 𝓟[ty]1816{ActorConstructor} = {CONSTRUCTOR: (any)->𝓟[ty]512{Actor}, getType: ()->𝓛[ty]10051{String}, createBefor: (any,𝓟[ty]412{Domain})->any, parse: (any)->𝓟[ty]512{Actor}}
const 𝓟494{uncommittedEvents} = 𝓛10031{Symbol}.for(𝓛8743{String});
const 𝓟495{loadEvents} = 𝓛10031{Symbol}.for(𝓛8743{String});
const 𝓟496{uuid} = 𝓛10097{require}(𝓛8743{String}).v1;
const 𝓟497{setdata} = 𝓛10031{Symbol}.for(𝓛8743{String});
const 𝓟498{isLock} = 𝓛10031{Symbol}.for(𝓛8743{String});
function 𝓟499{CONSTRUCTOR} (𝓟500{data}): (𝓟[ty]512{Actor})
{
const 𝓟[ty]512{Actor};
const 𝓟[ty]512{Actor};
𝓟[ty]512{Actor}.lockData ⟵ {key: 𝓛12563{undefined},timeout: 𝓛8745{Number},latestLockTime: 𝓛8747{Date}.CONSTRUCTOR(),isLock: 𝓛8744{Boolean}};
𝓟[ty]512{Actor}.access(𝓟494{uncommittedEvents}) ⟵ 𝓛8757{Array}();
𝓟[ty]512{Actor}.data ⟵ 𝓟500{data};
𝓟[ty]512{Actor}.data.isAlive ⟵ 𝓛8744{Boolean};
if (𝓛12548{ExclamationToken}(𝓟[ty]512{Actor}.data.id))
{
𝓟[ty]512{Actor}.data.id ⟵ 𝓟496{uuid}();
}
}
function 𝓟504{getType} (): (𝓟505: 𝓛[ty]10051{String})
{
return 𝓟505 = 𝓟[ty]512{Actor}.name
}
function 𝓟506{toJSON} (𝓟507{actor}: [OOV]𝓟[ty]512{Actor}): (𝓟508: [OOV]any)
{
return 𝓟508 = 𝓛8756{JSON}.parse(𝓛8756{JSON}.stringify(𝓟507{actor}.data))
}
function 𝓟509{parse} (𝓟510{json}): (𝓟511: [OOV]𝓟[ty]512{Actor})
{
return 𝓟511 = 𝓟[ty]512{Actor}.CONSTRUCTOR(𝓟510{json})
}
class 𝓟[ty]512{Actor}{
𝓟514{latestLockTime}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8635{Date});
𝓟515{data}: [OOV]any;
𝓟516{service}: [OOV]any;
𝓟517{$}: [OOV]any;
𝓟518{lockData}: [miss]𝓛[ty]8642{Object};
function 𝓟536{$ComputedPropertyName} (𝓟537{key}): (𝓟538: [miss]𝓛[ty]8666{Boolean})
{
if (𝓟[ty]512{Actor}.lockData.key)
{
if (𝓟[ty]512{Actor}.lockData.key.EqualsEqualsEqualsToken(𝓟537{key}))
{
return 𝓟538 = 𝓛8744{Boolean}
}
else
{
return 𝓟538 = 𝓟[ty]512{Actor}.lockData.isLock.AmpersandAmpersandToken(𝓛8747{Date}.now().MinusToken(𝓟[ty]512{Actor}.lockData.latestLockTime.getTime()).FirstBinaryOperator(𝓟[ty]512{Actor}.lockData.timeout))
}
}
else
{
return 𝓟538 = 𝓛8744{Boolean}
}
}
function 𝓟530{json} (): (𝓟531)
{
let 𝓟532{self}: [OOV]any = 𝓟[ty]512{Actor};
let 𝓟533{data} = 𝓟532{self}.constructor.toJSON(𝓟[ty]512{Actor});
𝓛8741{Object}.freeze(𝓟533{data})
return 𝓟531 = 𝓟533{data}
}
function 𝓟541{lock} (𝓟542{data}: [OOV]𝓟[ty]1812{LockDataType}): (𝓟543: [miss]𝓛[ty]8666{Boolean})
{
if (𝓟[ty]512{Actor}.lockData.key.EqualsEqualsEqualsToken(𝓟542{data}.key))
{
return 𝓟543 = 𝓛8744{Boolean}
}
if (𝓟[ty]512{Actor}.lockData.isLock.AmpersandAmpersandToken(𝓛8747{Date}.now().MinusToken(𝓟[ty]512{Actor}.lockData.latestLockTime.getTime()).FirstBinaryOperator(𝓟[ty]512{Actor}.lockData.timeout)))
{
return 𝓟543 = 𝓛8744{Boolean}
}
else
{
𝓟[ty]512{Actor}.lockData.timeout ⟵ 𝓟542{data}.timeout.BarBarToken(𝓛8745{Number});
𝓟[ty]512{Actor}.lockData.key ⟵ 𝓟542{data}.key;
𝓟[ty]512{Actor}.lockData.isLock ⟵ 𝓛8744{Boolean};
𝓟[ty]512{Actor}.lockData.latestLockTime ⟵ 𝓛8747{Date}.CONSTRUCTOR();
return 𝓟543 = 𝓛8744{Boolean}
}
}
function 𝓟544{unlock} (𝓟545{key}): (𝓟546: [miss]𝓛[ty]10033{Void})
{
if (𝓟[ty]512{Actor}.lockData.key.EqualsEqualsEqualsToken(𝓟545{key}))
{
𝓟[ty]512{Actor}.lockData.key ⟵ 𝓛12563{undefined};
}
}
function 𝓟521{version} (): (𝓟522)
{
return 𝓟522 = 𝓟[ty]512{Actor}.constructor.access(𝓛8743{String})
}
function 𝓟528{id} (): (𝓟529)
{
return 𝓟529 = 𝓟[ty]512{Actor}.json.id
}
function 𝓟539{remove} (): (𝓟540: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]512{Actor}.$()
}
function 𝓟523{getStore} (): (𝓟524: [miss]𝓛[ty]10033{Void})
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
function 𝓟534{updater} (): (𝓟535)
{
return 𝓟535 = {}
}
function 𝓟519{type} (): (𝓟520: 𝓛[ty]10051{String})
{
return 𝓟520 = 𝓟[ty]512{Actor}.constructor.access(𝓛8743{String})()
}
}
Module: src/lib/EventBus
const 𝓟579{uncommittedEvents} = 𝓛10031{Symbol}.for(𝓛8743{String});
function 𝓟580{CONSTRUCTOR} (𝓟581{eventstore}: [OOV]𝓟[ty]1822{EventStore},𝓟582{domain}: [OOV]𝓟[ty]412{Domain},𝓟583{repositorieMap}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]3199{Map}),𝓟584{ActorClassMap}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]3199{Map})): (𝓟[ty]601{EventBus})
{
const 𝓟[ty]601{EventBus};
const 𝓟[ty]601{EventBus};
𝓟[ty]601{EventBus}.subscribeRepo ⟵ 𝓛2995{Map}.CONSTRUCTOR();
𝓟[ty]601{EventBus}.lockSet ⟵ 𝓛2997{Set}.CONSTRUCTOR();
𝓟[ty]601{EventBus}.emitter ⟵ 𝓛6144{CONSTRUCTOR}();
function 𝓟588{$Lambda17} (𝓟589{events}): (𝓟590: [miss]𝓛[ty]10033{Void})
{
{
let 𝓟591{event} = 𝓛12552{$ArrayAccess}(𝓟589{events});
while (𝓛8744{Boolean})
{
const 𝓟592{alias} = 𝓟155{getAlias}(𝓟591{event});
{
let 𝓟593{name} = 𝓛12552{$ArrayAccess}(𝓟592{alias});
while (𝓛8744{Boolean})
{
function 𝓟594{$Lambda18} (): (𝓟595: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]601{EventBus}.emitter.emit(𝓟593{name},𝓟591{event})
const 𝓟596{s}: [miss]𝓛[ty]5956{Set} = 𝓟[ty]601{EventBus}.subscribeRepo.get(𝓟593{name});
if (𝓟596{s})
{
{
let 𝓟597{handle}: [miss]𝓛[ty]8642{Object} = 𝓛12552{$ArrayAccess}(𝓟596{s});
while (𝓛8744{Boolean})
{
function 𝓟598{$Lambda19} (𝓟599{actor}): (𝓟600: [miss]𝓛[ty]10033{Void})
{
𝓟599{actor}.access(𝓟597{handle}.method)(𝓟591{event})
}
𝓟[ty]601{EventBus}.domain.get(𝓟597{handle}.actorType,𝓟597{handle}.actorId).then(𝓟598{$Lambda19})
}
}
}
𝓟[ty]601{EventBus}.subscribeRepo.delete(𝓟593{name})
}
𝓛1{<UNKNOWN>}(𝓟594{$Lambda18})
}
}
}
}
}
𝓟[ty]601{EventBus}.eventstore.on(𝓛8743{String},𝓟588{$Lambda17})
}
class 𝓟[ty]601{EventBus}{
𝓟603{emitter};
𝓟604{lockSet}: [miss]𝓛[ty]5956{Set};
𝓟605{subscribeRepo}: [miss]𝓛[ty]3199{Map};
function 𝓟606{once} (𝓟607{event}: [OOV]𝓟[ty]1823{EventType},𝓟608{cb}: 𝓛[ty]8696{Function}): (𝓟609: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8654{Promise}))
{
function 𝓟610{$Lambda20} (𝓟611{resolve},𝓟612{reject}): (𝓟613: [miss]𝓛[ty]10033{Void})
{
function 𝓟614{$Lambda21} (𝓟615{event}): (𝓟616: [miss]𝓛[ty]10033{Void})
{
𝓟611{resolve}(𝓟615{event})
if (𝓟608{cb})
{
function 𝓟617{$Lambda22} (): (𝓟618: [OOV]any)
{
return 𝓟618 = 𝓟608{cb}(𝓟615{event})
}
𝓛10082{setImmediate}(𝓟617{$Lambda22})
}
}
𝓟[ty]601{EventBus}.emitter.once(𝓟155{getAlias}(𝓟607{event}),𝓟614{$Lambda21})
}
return 𝓟609 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟610{$Lambda20})
}
function 𝓟648{$Async_rollback} (𝓟649{sagaId}): (𝓟650: [miss]𝓛[ty]8654{Promise})
{
𝓛12547{$Await}(𝓟[ty]601{EventBus}.eventstore.killSaga(𝓟649{sagaId}))
const 𝓟651{events}: [miss]𝓛[ty]8670{Array} = 𝓛12547{$Await}(𝓟[ty]601{EventBus}.eventstore.findEventsBySagaId(𝓟649{sagaId}));
𝓛12547{$Await}(𝓟[ty]601{EventBus}.eventstore.removeEventsBySagaId(𝓟649{sagaId}))
function 𝓟652{$Lambda25} (𝓟653{event}): (𝓟654: [miss]𝓛[ty]10033{Void})
{
const 𝓟655{Class}: [OOV]𝓟[ty]1816{ActorConstructor} = 𝓟[ty]601{EventBus}.ActorClassMap.get(𝓟653{event}.actorType);
const 𝓟656{repo}: [OOV]𝓟[ty]168{Repository} = 𝓟[ty]601{EventBus}.repositorieMap.get(𝓟655{Class});
𝓟656{repo}.clear(𝓟653{event}.actorId)
}
𝓛1{<UNKNOWN>}(𝓟652{$Lambda25})
}
function 𝓟619{subscribe} (𝓟620{event}: [OOV]𝓟[ty]1823{EventType},𝓟621{_}: 𝓛[ty]8642{Object},𝓟622{timeout}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8655{Number})): (𝓟623: [miss]𝓛[ty]10033{Void})
{
}
function 𝓟626{on} (𝓟627{event}: [OOV]𝓟[ty]1823{EventType},𝓟628{cb}: 𝓛[ty]8696{Function}): (𝓟629: [miss]𝓛[ty]10033{Void})
{
function 𝓟630{$Lambda23} (𝓟631{event}): (𝓟632: [miss]𝓛[ty]10033{Void})
{
𝓟628{cb}(𝓟631{event})
}
𝓟[ty]601{EventBus}.emitter.on(𝓟155{getAlias}(𝓟627{event}),𝓟630{$Lambda23})
}
function 𝓟633{$Async_publish} (𝓟634{actor}: [OOV]𝓟[ty]512{Actor}): (𝓟635: [miss]𝓛[ty]8654{Promise})
{
if (𝓟[ty]601{EventBus}.lockSet.has(𝓟634{actor}.id))
{
}
else
{
𝓟[ty]601{EventBus}.lockSet.add(𝓟634{actor}.id)
}
const 𝓟636{event} = 𝓛12547{$Await}(𝓟[ty]601{EventBus}.eventstore.getLatestEvent(𝓟634{actor}.id));
let 𝓟637{startIndex} = (𝓟636{event} ? 𝓟636{event}.index.PlusToken(𝓛8745{Number}) : 𝓛8745{Number};
function 𝓟638{$Lambda24} (𝓟639{evt},𝓟640{index}): (𝓟641: [OOV]any)
{
𝓟639{evt}.index ⟵ 𝓟640{index}.PlusToken(𝓟637{startIndex});
return 𝓟641 = 𝓟639{evt}
}
let 𝓟642{events} = 𝓟634{actor}.access(𝓟579{uncommittedEvents}).map(𝓟638{$Lambda24});
𝓛12547{$Await}(𝓟[ty]601{EventBus}.eventstore.saveEvents(𝓟642{events}))
𝓟634{actor}.access(𝓟579{uncommittedEvents}) ⟵ 𝓛8757{Array}();
let 𝓟643{snap} = 𝓛12547{$Await}(𝓟[ty]601{EventBus}.eventstore.getLatestSnapshot(𝓟634{actor}.id));
let 𝓟644{lastEvent} = 𝓛1{<UNKNOWN>}(𝓛1{<UNKNOWN>}.MinusToken(𝓛8745{Number}));
if (𝓟644{lastEvent}.index.MinusToken(𝓟643{snap}.lastEventId).GreaterThanToken(𝓛8745{Number}))
{
let 𝓟645{latestEventIndex} = 𝓟644{lastEvent}.index;
let 𝓟646{index} = 𝓟643{snap}.index.PlusToken(𝓛8745{Number});
let 𝓟647{newSnap}: [OOV]𝓟[ty]559{Snap} = 𝓟548{CONSTRUCTOR}(𝓟634{actor},𝓟646{index},𝓟645{latestEventIndex});
𝓛12547{$Await}(𝓟[ty]601{EventBus}.eventstore.createSnap(𝓟647{newSnap}))
}
𝓟[ty]601{EventBus}.lockSet.delete(𝓟634{actor}.id)
if (𝓟634{actor}.access(𝓟579{uncommittedEvents}).length)
{
𝓛12547{$Await}(𝓟[ty]601{EventBus}.publish(𝓟634{actor}))
}
}
function 𝓟624{unsubscribe} (): (𝓟625: [miss]𝓛[ty]10033{Void})
{
}
}