LibAcc: 0.5474=127/232, ProjAcc: 0.6216=23/37, Missing: 657
Module: example/ModelHookPlugin
function 𝓟1{CONSTRUCTOR} (): (𝓟[ty]5{LowercaseCollectionsPlugin})
{
const 𝓟[ty]5{LowercaseCollectionsPlugin};
const 𝓟[ty]5{LowercaseCollectionsPlugin};
}
class 𝓟[ty]5{LowercaseCollectionsPlugin} extends 𝓛[ty]2{<UNKNOWN>}{
function 𝓟7{newModel} (𝓟8{model}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟9: [miss]𝓛[ty]10033{Void})
{
𝓟8{model}.collectionName ⟵ 𝓟8{model}.collectionName.toLowerCase();
}
}
Module: lib/Instance
const 𝓟10{onCreating}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function});
const 𝓟11{onRetrieved}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function});
const 𝓟12{onReady}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function});
const 𝓟13{onSaving}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function});
const 𝓟14{collection}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]10051{String});
const 𝓟15{schema}: [OOV]𝓟[ty]501{Schema} = {_id: 𝓛8744{Boolean}};
const 𝓟16{validators}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}) = 𝓟195{DefaultValidators}();
const 𝓟17{transforms}: [OOV]𝓟[ty]772{Transforms} = {};
const 𝓟18{cache}: [OOV]𝓟[ty]500{CacheDirector};
const 𝓟19{indexes}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
const 𝓟20{mapReduceOptions}: [OOV]𝓟[ty]764{MapReduceFunctions};
function 𝓟21{CONSTRUCTOR} (𝓟22{model}: 𝓟[ty]947{Model},𝓟23{document}: [OOV]any,𝓟24{isNew}: 𝓛[ty]8666{Boolean},𝓟25{isPartial}: 𝓛[ty]8666{Boolean}): (𝓟[ty]32{Instance})
{
const 𝓟[ty]32{Instance};
const 𝓟[ty]32{Instance};
𝓟[ty]32{Instance}._model ⟵ 𝓟22{model};
𝓟[ty]32{Instance}._isNew ⟵ 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟24{isNew}));
𝓟[ty]32{Instance}._isPartial ⟵ 𝓟25{isPartial};
𝓟[ty]32{Instance}._original ⟵ 𝓟23{document};
𝓟[ty]32{Instance}._modified ⟵ 𝓟22{model}.helpers.cloneDocument(𝓟23{document});
function 𝓟29{$Lambda103} (𝓟30{plugin}: [OOV]𝓟[ty]1586{Plugin}): (𝓟31: [miss]𝓛[ty]10033{Void})
{
if (𝓟30{plugin}.newInstance)
{
𝓟30{plugin}.newInstance(𝓟[ty]32{Instance},𝓟22{model})
}
}
𝓛1{<UNKNOWN>}(𝓟22{model}.core.plugins,𝓟29{$Lambda103})
}
class 𝓟[ty]32{Instance}{
𝓟34{_original}: [OOV]any;
𝓟35{_isPartial}: 𝓛[ty]8666{Boolean};
𝓟36{_modified}: [OOV]any;
𝓟37{_isNew}: 𝓛[ty]8666{Boolean};
𝓟38{_model}: 𝓟[ty]947{Model};
function 𝓟114{refresh} (𝓟115{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟116: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟117{conditions}: [miss]𝓛[ty]8642{Object} = {_id: 𝓟[ty]32{Instance}._original._id};
function 𝓟118{$Lambda119} (): (𝓟119: [OOV]any)
{
function 𝓟120{$Lambda120} (𝓟121{resolve},𝓟122{reject}): (𝓟123: [miss]𝓛[ty]10033{Void})
{
function 𝓟124{$Lambda121} (𝓟125{err}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10053{Error}),𝓟126{doc}: [OOV]any): (𝓟127: [OOV]any)
{
if (𝓟125{err})
{
return 𝓟127 = 𝓟122{reject}(𝓟125{err})
}
return 𝓟127 = 𝓟121{resolve}(𝓟126{doc})
}
𝓟[ty]32{Instance}._model.collection.find(𝓟117{conditions}).limit(𝓛8745{Number}).next(𝓟124{$Lambda121})
}
return 𝓟119 = 𝓛23475{CONSTRUCTOR}(𝓟120{$Lambda120})
}
function 𝓟128{$Lambda122} (𝓟129{newDocument}): (𝓟130: [OOV]any)
{
if (𝓛12569{ExclamationToken}(𝓟129{newDocument}))
{
𝓟[ty]32{Instance}._isPartial ⟵ 𝓛8744{Boolean};
𝓟[ty]32{Instance}._isNew ⟵ 𝓛8744{Boolean};
𝓟[ty]32{Instance}._original ⟵ 𝓟[ty]32{Instance}._model.helpers.cloneDocument(𝓟[ty]32{Instance}._modified);
return 𝓟130 = 𝓟[ty]32{Instance} as any as 𝓛[ty]2{<UNKNOWN>}
}
function 𝓟131{$Lambda123} (𝓟132{doc}): (𝓟133: [OOV]any)
{
𝓟[ty]32{Instance}._isNew ⟵ 𝓛8744{Boolean};
𝓟[ty]32{Instance}._isPartial ⟵ 𝓛8744{Boolean};
𝓟[ty]32{Instance}._original ⟵ 𝓟132{doc};
𝓟[ty]32{Instance}._modified ⟵ 𝓟[ty]32{Instance}._model.helpers.cloneDocument(𝓟132{doc});
return 𝓟133 = 𝓟[ty]32{Instance} as any as 𝓛[ty]2{<UNKNOWN>}
}
return 𝓟130 = 𝓟[ty]32{Instance}._model.handlers.documentReceived(𝓟117{conditions},𝓟129{newDocument},𝓟131{$Lambda123})
}
return 𝓟116 = 𝓛23509{resolve}().then(𝓟118{$Lambda119}).then(𝓟128{$Lambda122}).nodeify(𝓟115{callback})
}
function 𝓟39{document} (): (𝓟40: [OOV]any)
{
return 𝓟40 = 𝓟[ty]32{Instance}._modified
}
function 𝓟181{select} (𝓟182{collection}: [OOV]any,𝓟183{predicate}: [OOV]𝓟[ty]1391{Predicate}): (𝓟184: [OOV]any)
{
let 𝓟185{isArray}: [miss]𝓛[ty]8666{Boolean} = 𝓛8757{Array}.isArray(𝓟182{collection});
let 𝓟186{results}: [OOV]any = (𝓟185{isArray} ? 𝓛8757{Array}() : {};
function 𝓟187{$Lambda130} (𝓟188{value}: [OOV]any,𝓟189{key}: 𝓛[ty]10051{String}): (𝓟190: [miss]𝓛[ty]10033{Void})
{
if (𝓟183{predicate}.call(𝓟[ty]32{Instance},𝓟188{value},𝓟189{key}))
{
if (𝓟185{isArray})
{
𝓟186{results}.push(𝓟188{value})
}
else
{
𝓟186{results}.access(𝓟189{key}) ⟵ 𝓟188{value};
}
}
}
𝓛1{<UNKNOWN>}(𝓟182{collection},𝓟187{$Lambda130})
return 𝓟184 = 𝓟186{results}
}
function 𝓟137{remove} (𝓟138{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟139: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟140{conditions}: [miss]𝓛[ty]8642{Object} = {_id: 𝓟[ty]32{Instance}._original._id};
function 𝓟141{$Lambda124} (): (𝓟142: [OOV]any)
{
if (𝓟[ty]32{Instance}._isNew)
{
return 𝓟142 = 𝓛8745{Number}
}
function 𝓟143{$Lambda125} (𝓟144{resolve},𝓟145{reject}): (𝓟146: [miss]𝓛[ty]10033{Void})
{
function 𝓟147{$Lambda126} (𝓟148{err}: (𝓟[ty]552{ModelCache} ≠ 𝓛[ty]10053{Error}),𝓟149{removed}: [OOV]any): (𝓟150: [OOV]any)
{
if (𝓟148{err})
{
return 𝓟150 = 𝓟145{reject}(𝓟148{err})
}
return 𝓟150 = 𝓟144{resolve}(𝓟149{removed})
}
𝓟[ty]32{Instance}._model.collection.deleteOne(𝓟140{conditions},{w: 𝓛8743{String}},𝓟147{$Lambda126})
}
return 𝓟142 = 𝓛23475{CONSTRUCTOR}(𝓟143{$Lambda125})
}
function 𝓟151{$Lambda127} (𝓟152{removed}): (𝓟153: [OOV]any)
{
if (𝓟152{removed})
{
return 𝓟153 = 𝓟[ty]32{Instance}._model.cache.clear(𝓟140{conditions})
}
return 𝓟153 = 𝓛8744{Boolean}
}
function 𝓟154{$Lambda128} (): (𝓟155: [OOV]any)
{
𝓟[ty]32{Instance}._isNew ⟵ 𝓛8744{Boolean};
return 𝓟155 = 𝓟[ty]32{Instance} as any as 𝓛[ty]2{<UNKNOWN>}
}
return 𝓟139 = 𝓛23509{resolve}().then(𝓟141{$Lambda124}).then(𝓟151{$Lambda127}).then(𝓟154{$Lambda128}).nodeify(𝓟138{callback})
}
function 𝓟134{delete} (𝓟135{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟136: [OOV]𝓛[ty]2{<UNKNOWN>})
{
return 𝓟136 = 𝓟[ty]32{Instance}.remove(𝓟135{callback})
}
function 𝓟164{first} (𝓟165{collection}: [OOV]any,𝓟166{predicate}: [OOV]𝓟[ty]1391{Predicate}): (𝓟167: [OOV]any)
{
let 𝓟168{result}: [OOV]any = 𝓛12643{undefined};
function 𝓟169{$Lambda129} (𝓟170{value}: [OOV]any,𝓟171{key}: 𝓛[ty]10051{String}): (𝓟172: [miss]𝓛[ty]8666{Boolean})
{
if (𝓟166{predicate}.call(𝓟[ty]32{Instance},𝓟170{value},𝓟171{key}))
{
𝓟168{result} ⟵ 𝓟170{value};
return 𝓟172 = 𝓛8744{Boolean}
}
}
𝓛1{<UNKNOWN>}(𝓟165{collection},𝓟169{$Lambda129})
return 𝓟167 = 𝓟168{result}
}
function 𝓟193{toString} (): (𝓟194: 𝓛[ty]10051{String})
{
return 𝓟194 = 𝓛8756{JSON}.stringify(𝓟[ty]32{Instance}.document,𝓛12643{undefined},𝓛8745{Number})
}
function 𝓟111{update} (𝓟112{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟113: [OOV]𝓛[ty]2{<UNKNOWN>})
{
return 𝓟113 = 𝓟[ty]32{Instance}.refresh(𝓟112{callback})
}
function 𝓟53{save} (𝓟54{args}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟55: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟56{callback}: [OOV]any = 𝓛12643{undefined};
let 𝓟57{changes}: [OOV]any = 𝓛12643{undefined};
let 𝓟58{conditions}: [OOV]any = {};
function 𝓟59{$Lambda104} (𝓟60{arg}: [OOV]any): (𝓟61: [miss]𝓛[ty]10033{Void})
{
if (𝓛12599{EqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟60{arg}),𝓛8743{String}))
{
𝓟56{callback} ⟵ 𝓟60{arg};
}
else
{
if (𝓛12599{EqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟60{arg}),𝓛8743{String}))
{
if (𝓛12569{ExclamationToken}(𝓟57{changes}))
{
𝓟57{changes} ⟵ 𝓟60{arg};
}
else
{
𝓟58{conditions} ⟵ 𝓟60{arg};
}
}
}
}
𝓛8757{Array}.prototype.slice.call(𝓟54{args},𝓛8745{Number}).reverse().forEach(𝓟59{$Lambda104})
function 𝓟62{$Lambda105} (): (𝓟63: [OOV]any)
{
𝓟58{conditions} ⟵ 𝓟[ty]32{Instance}._model.helpers.cloneConditions(𝓟58{conditions});
𝓛1{<UNKNOWN>}(𝓟58{conditions},{_id: 𝓟[ty]32{Instance}._modified._id})
if (𝓛12569{ExclamationToken}(𝓟57{changes}))
{
let 𝓟64{validation} = 𝓟[ty]32{Instance}._model.helpers.validate(𝓟[ty]32{Instance}._modified);
if (𝓟64{validation}.failed)
{
return 𝓟63 = 𝓛23512{reject}(𝓟64{validation}.error).bind(𝓟[ty]32{Instance}).nodeify(𝓟56{callback})
}
let 𝓟65{original}: [OOV]any = 𝓟[ty]32{Instance}._model.helpers.cloneDocument(𝓟[ty]32{Instance}._original);
let 𝓟66{modified}: [OOV]any = 𝓟[ty]32{Instance}._model.helpers.cloneDocument(𝓟[ty]32{Instance}._modified);
𝓟66{modified} ⟵ 𝓟[ty]32{Instance}._model.helpers.transformToDB(𝓟66{modified},{document: 𝓛8744{Boolean}});
𝓟57{changes} ⟵ 𝓟[ty]32{Instance}._model.helpers.diff(𝓟65{original},𝓟66{modified});
}
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟57{changes}).length))
{
return 𝓟63 = 𝓛12643{undefined}
}
return 𝓟63 = 𝓟57{changes}
}
function 𝓟67{$Lambda106} (𝓟68{changes}): (𝓟69: [OOV]any)
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟68{changes}),𝓛12569{ExclamationToken}(𝓟[ty]32{Instance}._isNew)))
{
return 𝓟69 = 𝓟68{changes}
}
function 𝓟70{$Lambda107} (): (𝓟71: [OOV]any)
{
return 𝓟71 = 𝓟68{changes}
}
return 𝓟69 = 𝓟[ty]32{Instance}._model.handlers.savingDocument(𝓟[ty]32{Instance} as any as 𝓛[ty]2{<UNKNOWN>},𝓟68{changes}).then(𝓟70{$Lambda107})
}
function 𝓟72{$Lambda108} (𝓟73{changes}): (𝓟74: [OOV]any)
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟73{changes}),𝓛12569{ExclamationToken}(𝓟[ty]32{Instance}._isNew)))
{
return 𝓟74 = 𝓛8744{Boolean}
}
if (𝓟[ty]32{Instance}._isNew)
{
function 𝓟75{$Lambda109} (𝓟76{resolve},𝓟77{reject}): (𝓟78: [miss]𝓛[ty]10033{Void})
{
function 𝓟79{$Lambda110} (𝓟80{err},𝓟81{doc}): (𝓟82: [OOV]any)
{
if (𝓟80{err})
{
return 𝓟82 = 𝓟77{reject}(𝓟80{err})
}
return 𝓟82 = 𝓟76{resolve}(𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟81{doc})) as any)
}
𝓟[ty]32{Instance}._model.collection.insertOne(𝓟[ty]32{Instance}._modified,{w: 𝓛8743{String}},𝓟79{$Lambda110})
}
return 𝓟74 = 𝓛23475{CONSTRUCTOR}(𝓟75{$Lambda109})
}
else
{
function 𝓟83{$Lambda111} (𝓟84{resolve},𝓟85{reject}): (𝓟86: [miss]𝓛[ty]10033{Void})
{
function 𝓟87{$Lambda112} (𝓟88{err},𝓟89{changed}): (𝓟90: [OOV]any)
{
if (𝓟88{err})
{
𝓟88{err} as any.access(𝓛8743{String}) ⟵ 𝓟58{conditions};
𝓟88{err} as any.access(𝓛8743{String}) ⟵ 𝓟73{changes};
return 𝓟90 = 𝓟85{reject}(𝓟88{err})
}
return 𝓟90 = 𝓟84{resolve}(𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟89{changed}.modifiedCount)))
}
𝓟[ty]32{Instance}._model.collection.updateOne(𝓟58{conditions},𝓟73{changes},{w: 𝓛8743{String}},𝓟87{$Lambda112})
}
return 𝓟74 = 𝓛23475{CONSTRUCTOR}(𝓟83{$Lambda111})
}
}
function 𝓟91{$Lambda113} (𝓟92{err}): (𝓟93: [OOV]any)
{
𝓟92{err}.access(𝓛8743{String}) ⟵ 𝓟[ty]32{Instance}._original;
𝓟92{err}.access(𝓛8743{String}) ⟵ 𝓟[ty]32{Instance}._modified;
return 𝓟93 = 𝓛23512{reject}(𝓟92{err})
}
function 𝓟94{$Lambda114} (𝓟95{changed}: 𝓛[ty]8666{Boolean}): (𝓟96: [OOV]any)
{
𝓟58{conditions} ⟵ {_id: 𝓟[ty]32{Instance}._modified._id};
if (𝓛12569{ExclamationToken}(𝓟95{changed}))
{
return 𝓟96 = 𝓟[ty]32{Instance}._modified
}
function 𝓟97{$Lambda115} (𝓟98{resolve},𝓟99{reject}): (𝓟100: [miss]𝓛[ty]10033{Void})
{
function 𝓟101{$Lambda116} (𝓟102{err}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10053{Error}),𝓟103{latest}: [OOV]any): (𝓟104: [OOV]any)
{
if (𝓟102{err})
{
return 𝓟104 = 𝓟99{reject}(𝓟102{err})
}
return 𝓟104 = 𝓟98{resolve}(𝓟103{latest})
}
𝓟[ty]32{Instance}._model.collection.find(𝓟58{conditions}).limit(𝓛8745{Number}).next(𝓟101{$Lambda116})
}
return 𝓟96 = 𝓛23475{CONSTRUCTOR}(𝓟97{$Lambda115})
}
function 𝓟105{$Lambda117} (𝓟106{latest}: [OOV]any): (𝓟107: [OOV]any)
{
if (𝓛12569{ExclamationToken}(𝓟106{latest}))
{
𝓟[ty]32{Instance}._isNew ⟵ 𝓛8744{Boolean};
𝓟[ty]32{Instance}._original ⟵ 𝓟[ty]32{Instance}._model.helpers.cloneDocument(𝓟[ty]32{Instance}._modified);
return 𝓟107 = 𝓛23509{resolve}(𝓟[ty]32{Instance} as any as 𝓛[ty]2{<UNKNOWN>})
}
function 𝓟108{$Lambda118} (𝓟109{value}): (𝓟110: [OOV]any)
{
𝓟[ty]32{Instance}._isPartial ⟵ 𝓛8744{Boolean};
𝓟[ty]32{Instance}._isNew ⟵ 𝓛8744{Boolean};
𝓟[ty]32{Instance}._modified ⟵ 𝓟109{value};
𝓟[ty]32{Instance}._original ⟵ 𝓟[ty]32{Instance}._model.helpers.cloneDocument(𝓟109{value});
return 𝓟110 = 𝓟[ty]32{Instance} as any as 𝓛[ty]2{<UNKNOWN>}
}
return 𝓟107 = 𝓟[ty]32{Instance}._model.handlers.documentReceived(𝓟58{conditions},𝓟106{latest},𝓟108{$Lambda118})
}
return 𝓟55 = 𝓛23509{resolve}().then(𝓟62{$Lambda105}).then(𝓟67{$Lambda106}).then(𝓟72{$Lambda108}).catch(𝓟91{$Lambda113}).then(𝓟94{$Lambda114}).then(𝓟105{$Lambda117}).nodeify(𝓟56{callback})
}
function 𝓟191{toJSON} (): (𝓟192: [OOV]any)
{
return 𝓟192 = 𝓟[ty]32{Instance}.document
}
}
Module: lib/Validators
function 𝓟195{DefaultValidators} (): (𝓟196: [miss]𝓛[ty]8670{Array})
{
function 𝓟197{$Lambda193} (𝓟198{schema}): (𝓟199: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟199 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟198{schema},𝓛1{<UNKNOWN>})
}
function 𝓟200{$Lambda194} (𝓟201{schema},𝓟202{data}): (𝓟203: [OOV]any)
{
return 𝓟203 = 𝓛12552{this}.assert(𝓛12546{BarBarToken}(𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟202{data}),𝓛1{<UNKNOWN>}(𝓟202{data},𝓛1{<UNKNOWN>})),𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟202{data}._bsontype,𝓛8743{String}),𝓟202{data}.id)),𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓛8756{JSON}.stringify(𝓟202{data})),𝓛8743{String}))
}
function 𝓟204{$Lambda195} (𝓟205{schema}): (𝓟206: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟206 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟205{schema},𝓛10100{Buffer})
}
function 𝓟207{$Lambda196} (𝓟208{schema},𝓟209{data}): (𝓟210: [OOV]any)
{
return 𝓟210 = 𝓛12552{this}.assert(𝓛12592{AmpersandAmpersandToken}(𝓟209{data},𝓛12546{BarBarToken}(𝓛1{<UNKNOWN>}(𝓟209{data},𝓛1{<UNKNOWN>}),𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟209{data}._bsontype,𝓛8743{String}),𝓟209{data}.buffer))),𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓛8756{JSON}.stringify(𝓟209{data})),𝓛8743{String}))
}
return 𝓟196 = 𝓛8757{Array}(𝓛1{<UNKNOWN>}(𝓟197{$Lambda193},𝓟200{$Lambda194},{name: 𝓛8743{String}}),𝓛1{<UNKNOWN>}(𝓟204{$Lambda195},𝓟207{$Lambda196},{name: 𝓛8743{String}}))
}
Module: lib/ModelOptions
type 𝓟[ty]211{QueryOptions} = {skip: 𝓛[ty]8655{Number}, cache: 𝓛[ty]8666{Boolean}, fields: {access: (𝓛[ty]10051{String})->𝓛[ty]8655{Number}}, sort: 𝓟[ty]937{IndexSpecification}, limit: 𝓛[ty]8655{Number}}
type 𝓟[ty]212{RemoveOptions} = {w: any, wtimeout: 𝓛[ty]8655{Number}, j: 𝓛[ty]8666{Boolean}, single: 𝓛[ty]8666{Boolean}}
type 𝓟[ty]213{CreateOptions} = {j: 𝓛[ty]8655{Number}, forceServerObjectId: 𝓛[ty]8666{Boolean}, cache: 𝓛[ty]8666{Boolean}, wtimeout: 𝓛[ty]8655{Number}, w: any, serializeFunctions: 𝓛[ty]8666{Boolean}, upsert: 𝓛[ty]8666{Boolean}}
type 𝓟[ty]214{UpdateOptions} = {j: 𝓛[ty]8666{Boolean}, wtimeout: 𝓛[ty]8655{Number}, w: any, multi: 𝓛[ty]8666{Boolean}, upsert: 𝓛[ty]8666{Boolean}}
Module: lib/ModelSpecificInstance
type 𝓟[ty]215{InstanceConstructor} = {CONSTRUCTOR: (𝓛[ty]8670{Array})->any, prototype: any}
function 𝓟216{ModelSpecificInstance} (𝓟217{model}: 𝓟[ty]947{Model},𝓟218{instanceType}: [OOV]𝓟[ty]938{InstanceImplementation}): (𝓟219: [OOV]𝓟[ty]502{ModelSpecificInstanceConstructor})
{
const 𝓟220{instanceTypeConstructor}: [OOV]𝓟[ty]215{InstanceConstructor} = 𝓟218{instanceType} as any as 𝓟[ty]215{InstanceConstructor};
let 𝓟221{virtualClass} = 𝓛12643{undefined};
function 𝓟222{$Lambda184} (𝓟223{property}): (𝓟224: [OOV]any)
{
const 𝓟225{transform}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟217{model}.transforms.access(𝓟223{property});
if (𝓟225{transform})
{
function 𝓟226{$Lambda185} (𝓟227{this}: [OOV]𝓟[ty]939{InstanceInternals}): (𝓟228: [OOV]any)
{
return 𝓟228 = 𝓟225{transform}.fromDB(𝓟227{this}._modified as any.access(𝓟223{property}),𝓟223{property},𝓟217{model})
}
function 𝓟229{$Lambda186} (𝓟230{this}: [OOV]𝓟[ty]939{InstanceInternals},𝓟231{value}: [OOV]any): (𝓟232: [miss]𝓛[ty]10033{Void})
{
𝓟230{this}._modified as any.access(𝓟223{property}) ⟵ 𝓟225{transform}.toDB(𝓟231{value},𝓟223{property},𝓟217{model});
}
return 𝓟224 = 𝓛8741{Object}.defineProperty(𝓟221{virtualClass}.prototype,𝓟223{property},{get: 𝓟226{$Lambda185},set: 𝓟229{$Lambda186},enumerable: 𝓛8744{Boolean},configurable: 𝓛8744{Boolean}})
}
function 𝓟233{$Lambda187} (𝓟234{this}: [OOV]𝓟[ty]939{InstanceInternals}): (𝓟235: [OOV]any)
{
return 𝓟235 = 𝓟234{this}._modified as any.access(𝓟223{property})
}
function 𝓟236{$Lambda188} (𝓟237{this}: [OOV]𝓟[ty]939{InstanceInternals},𝓟238{value}: [OOV]any): (𝓟239: [miss]𝓛[ty]10033{Void})
{
𝓟237{this}._modified as any.access(𝓟223{property}) ⟵ 𝓟238{value};
}
𝓛8741{Object}.defineProperty(𝓟221{virtualClass}.prototype,𝓟223{property},{get: 𝓟233{$Lambda187},set: 𝓟236{$Lambda188},enumerable: 𝓛8744{Boolean}})
}
𝓛1{<UNKNOWN>}(𝓛8741{Object}.keys(𝓟217{model}.schema),𝓟222{$Lambda184})
return 𝓟219 = 𝓟221{virtualClass} as any
}
Module: lib/Cursor
function 𝓟240{CONSTRUCTOR} (𝓟241{model}: 𝓟[ty]947{Model},𝓟242{conditions}: [OOV]any,𝓟243{cursor}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟[ty]247{Cursor})
{
const 𝓟[ty]247{Cursor};
const 𝓟[ty]247{Cursor};
𝓟[ty]247{Cursor}.cursor ⟵ 𝓟243{cursor};
}
class 𝓟[ty]247{Cursor}{
𝓟249{cursor}: [OOV]𝓛[ty]2{<UNKNOWN>};
function 𝓟250{count} (𝓟251{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟252: [OOV]𝓛[ty]2{<UNKNOWN>})
{
function 𝓟253{$Lambda71} (𝓟254{resolve},𝓟255{reject}): (𝓟256: [miss]𝓛[ty]10033{Void})
{
function 𝓟257{$Lambda72} (𝓟258{err},𝓟259{count}): (𝓟260: [OOV]any)
{
if (𝓟258{err})
{
return 𝓟260 = 𝓟255{reject}(𝓟258{err})
}
return 𝓟260 = 𝓟254{resolve}(𝓟259{count})
}
𝓟[ty]247{Cursor}.cursor.count(𝓛8744{Boolean},𝓟257{$Lambda72})
}
return 𝓟252 = 𝓛23475{CONSTRUCTOR}(𝓟253{$Lambda71}).nodeify(𝓟251{callback})
}
function 𝓟278{map} (𝓟279{transform}: 𝓛[ty]8696{Function},𝓟280{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟281: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟282{helpers}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]247{Cursor}.model.helpers;
function 𝓟283{$Lambda77} (𝓟284{resolve},𝓟285{reject}): (𝓟286: [miss]𝓛[ty]10033{Void})
{
let 𝓟287{promises}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
function 𝓟288{$Lambda78} (𝓟289{item}: [OOV]any): (𝓟290: [miss]𝓛[ty]10033{Void})
{
function 𝓟291{$Lambda79} (): (𝓟292: [OOV]any)
{
return 𝓟292 = 𝓟282{helpers}.wrapDocument.apply(𝓟282{helpers},𝓛10035{arguments})
}
𝓟287{promises}.push(𝓟[ty]247{Cursor}.model.handlers.documentReceived(𝓟[ty]247{Cursor}.conditions,𝓟289{item},𝓟291{$Lambda79}).then(𝓟279{transform} as (𝓛[ty]2{<UNKNOWN>})->𝓛[ty]2{<UNKNOWN>}))
}
function 𝓟293{$Lambda80} (𝓟294{err}): (𝓟295: [OOV]any)
{
if (𝓟294{err})
{
return 𝓟295 = 𝓟285{reject}(𝓟294{err})
}
return 𝓟295 = 𝓟284{resolve}(𝓛23632{all}(𝓟287{promises}))
}
𝓟[ty]247{Cursor}.cursor.forEach(𝓟288{$Lambda78},𝓟293{$Lambda80})
}
return 𝓟281 = 𝓛23475{CONSTRUCTOR}(𝓟283{$Lambda77}).nodeify(𝓟280{callback})
}
function 𝓟261{forEach} (𝓟262{handler}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8696{Function}),𝓟263{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟264: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟265{helpers}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]247{Cursor}.model.helpers;
function 𝓟266{$Lambda73} (𝓟267{resolve},𝓟268{reject}): (𝓟269: [miss]𝓛[ty]10033{Void})
{
function 𝓟270{$Lambda74} (𝓟271{item}: [OOV]any): (𝓟272: [miss]𝓛[ty]10033{Void})
{
function 𝓟273{$Lambda75} (): (𝓟274: [OOV]any)
{
return 𝓟274 = 𝓟265{helpers}.wrapDocument.apply(𝓟265{helpers},𝓛10035{arguments})
}
𝓟[ty]247{Cursor}.model.handlers.documentReceived(𝓟[ty]247{Cursor}.conditions,𝓟271{item},𝓟273{$Lambda75}).then(𝓟262{handler})
}
function 𝓟275{$Lambda76} (𝓟276{err}): (𝓟277: [OOV]any)
{
if (𝓟276{err})
{
return 𝓟277 = 𝓟268{reject}(𝓟276{err})
}
return 𝓟277 = 𝓟267{resolve}(𝓛12643{undefined})
}
𝓟[ty]247{Cursor}.cursor.forEach(𝓟270{$Lambda74},𝓟275{$Lambda76})
}
return 𝓟264 = 𝓛23475{CONSTRUCTOR}(𝓟266{$Lambda73}).nodeify(𝓟263{callback})
}
function 𝓟369{skip} (𝓟370{skip}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟371: (𝓟[ty]386{Core} ≠ 𝓟[ty]247{Cursor}))
{
return 𝓟371 = 𝓟240{CONSTRUCTOR}(𝓟[ty]247{Cursor}.model,𝓟[ty]247{Cursor}.conditions,𝓟[ty]247{Cursor}.cursor.skip(𝓟370{skip}))
}
function 𝓟372{readFrom} (𝓟373{type}: 𝓛[ty]10051{String}): (𝓟374: (𝓟[ty]386{Core} ≠ 𝓟[ty]247{Cursor}))
{
return 𝓟374 = 𝓟240{CONSTRUCTOR}(𝓟[ty]247{Cursor}.model,𝓟[ty]247{Cursor}.conditions,𝓟[ty]247{Cursor}.cursor.setReadPreference(𝓟373{type}))
}
function 𝓟296{toArray} (𝓟297{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟298: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟299{helpers}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]247{Cursor}.model.helpers;
function 𝓟300{$Lambda81} (𝓟301{resolve},𝓟302{reject}): (𝓟303: [miss]𝓛[ty]10033{Void})
{
function 𝓟304{$Lambda82} (𝓟305{err}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10053{Error}),𝓟306{results}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]8670{Array})): (𝓟307: [OOV]any)
{
if (𝓟305{err})
{
return 𝓟307 = 𝓟302{reject}(𝓟305{err})
}
return 𝓟307 = 𝓟301{resolve}(𝓟306{results})
}
𝓟[ty]247{Cursor}.cursor.toArray(𝓟304{$Lambda82})
}
function 𝓟308{$Lambda83} (𝓟309{document}): (𝓟310: [OOV]any)
{
function 𝓟311{$Lambda84} (): (𝓟312: [OOV]any)
{
return 𝓟312 = 𝓟299{helpers}.wrapDocument.apply(𝓟299{helpers},𝓛10035{arguments})
}
return 𝓟310 = 𝓟[ty]247{Cursor}.model.handlers.documentReceived(𝓟[ty]247{Cursor}.conditions,𝓟309{document},𝓟311{$Lambda84})
}
return 𝓟298 = 𝓛23475{CONSTRUCTOR}(𝓟300{$Lambda81}).map(𝓟308{$Lambda83}).nodeify(𝓟297{callback})
}
function 𝓟313{next} (𝓟314{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟315: [OOV]𝓛[ty]2{<UNKNOWN>})
{
function 𝓟316{$Lambda85} (𝓟317{resolve},𝓟318{reject}): (𝓟319: [miss]𝓛[ty]10033{Void})
{
function 𝓟320{$Lambda86} (𝓟321{err}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10053{Error}),𝓟322{result}: [OOV]any): (𝓟323: [OOV]any)
{
if (𝓟321{err})
{
return 𝓟323 = 𝓟318{reject}(𝓟321{err})
}
return 𝓟323 = 𝓟317{resolve}(𝓟322{result})
}
𝓟[ty]247{Cursor}.cursor.next(𝓟320{$Lambda86})
}
function 𝓟324{$Lambda87} (𝓟325{document}): (𝓟326: [OOV]any)
{
if (𝓛12569{ExclamationToken}(𝓟325{document}))
{
return 𝓟326 = 𝓛23509{resolve}(𝓛12643{undefined})
}
function 𝓟327{$Lambda88} (𝓟328{document},𝓟329{isNew},𝓟330{isPartial}): (𝓟331: [OOV]any)
{
return 𝓟331 = 𝓟[ty]247{Cursor}.model.helpers.wrapDocument(𝓟328{document},𝓟329{isNew},𝓟330{isPartial})
}
return 𝓟326 = 𝓟[ty]247{Cursor}.model.handlers.documentReceived(𝓟[ty]247{Cursor}.conditions,𝓟325{document},𝓟327{$Lambda88})
}
return 𝓟315 = 𝓛23475{CONSTRUCTOR}(𝓟316{$Lambda85}).then(𝓟324{$Lambda87}).nodeify(𝓟314{callback})
}
function 𝓟363{sort} (𝓟364{sortExpression}: [OOV]𝓟[ty]937{IndexSpecification}): (𝓟365: (𝓟[ty]386{Core} ≠ 𝓟[ty]247{Cursor}))
{
return 𝓟365 = 𝓟240{CONSTRUCTOR}(𝓟[ty]247{Cursor}.model,𝓟[ty]247{Cursor}.conditions,𝓟[ty]247{Cursor}.cursor.sort(𝓟364{sortExpression}))
}
function 𝓟366{limit} (𝓟367{limit}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟368: (𝓟[ty]386{Core} ≠ 𝓟[ty]247{Cursor}))
{
return 𝓟368 = 𝓟240{CONSTRUCTOR}(𝓟[ty]247{Cursor}.model,𝓟[ty]247{Cursor}.conditions,𝓟[ty]247{Cursor}.cursor.limit(𝓟367{limit}))
}
function 𝓟332{one} (𝓟333{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟334: [OOV]𝓛[ty]2{<UNKNOWN>})
{
function 𝓟335{$Lambda89} (𝓟336{resolve},𝓟337{reject}): (𝓟338: [miss]𝓛[ty]10033{Void})
{
function 𝓟339{$Lambda90} (𝓟340{err}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10053{Error}),𝓟341{result}: [OOV]any): (𝓟342: [OOV]any)
{
if (𝓟340{err})
{
return 𝓟342 = 𝓟337{reject}(𝓟340{err})
}
return 𝓟342 = 𝓟336{resolve}(𝓟341{result})
}
𝓟[ty]247{Cursor}.cursor.next(𝓟339{$Lambda90})
}
function 𝓟343{$Lambda91} (𝓟344{document}): (𝓟345: [OOV]any)
{
function 𝓟346{$Lambda92} (𝓟347{resolve},𝓟348{reject}): (𝓟349: [miss]𝓛[ty]10033{Void})
{
function 𝓟350{$Lambda93} (𝓟351{err}): (𝓟352: [OOV]any)
{
if (𝓟351{err})
{
return 𝓟352 = 𝓟348{reject}(𝓟351{err})
}
return 𝓟352 = 𝓟347{resolve}(𝓟344{document})
}
𝓟[ty]247{Cursor}.cursor.close(𝓟350{$Lambda93})
}
return 𝓟345 = 𝓛23475{CONSTRUCTOR}(𝓟346{$Lambda92})
}
function 𝓟353{$Lambda94} (𝓟354{document}): (𝓟355: [OOV]any)
{
if (𝓛12569{ExclamationToken}(𝓟354{document}))
{
return 𝓟355 = 𝓛23509{resolve}(𝓛12643{undefined})
}
function 𝓟356{$Lambda95} (𝓟357{document},𝓟358{isNew},𝓟359{isPartial}): (𝓟360: [OOV]any)
{
return 𝓟360 = 𝓟[ty]247{Cursor}.model.helpers.wrapDocument(𝓟357{document},𝓟358{isNew},𝓟359{isPartial})
}
return 𝓟355 = 𝓟[ty]247{Cursor}.model.handlers.documentReceived(𝓟[ty]247{Cursor}.conditions,𝓟354{document},𝓟356{$Lambda95})
}
return 𝓟334 = 𝓛23475{CONSTRUCTOR}(𝓟335{$Lambda89}).then(𝓟343{$Lambda91}).then(𝓟353{$Lambda94}).nodeify(𝓟333{callback})
}
function 𝓟361{rewind} (): (𝓟362: 𝓟[ty]247{Cursor})
{
𝓟[ty]247{Cursor}.cursor.rewind()
return 𝓟362 = 𝓟[ty]247{Cursor}
}
}
Module: lib/BSON
type 𝓟[ty]375{BSONObject} = {access: (𝓛[ty]10051{String})->𝓟[ty]376{BSONType}}
type 𝓟[ty]376{BSONType} = any
type 𝓛[ty]8670{Array} = 𝓛[ty]8670{Array}
Module: lib/Cache
type 𝓟[ty]378{Cache} = {set: (𝓛[ty]10051{String},any)->𝓛[ty]10033{Void}, get: (𝓛[ty]10051{String})->𝓛[ty]8632{PromiseLike}, clear: (𝓛[ty]10051{String})->𝓛[ty]10033{Void}}
Module: lib/Hooks
type 𝓟[ty]379{Hooks} = {onCreating: (any)->any, onRetrieved: (any)->any, onReady: (any)->any, onSaving: (any,any)->any}
Module: example/UserModel
type 𝓟[ty]439{UserDocument} = {banned: 𝓛[ty]8666{Boolean}, email: 𝓛[ty]10051{String}, statistics: {won: 𝓛[ty]8655{Number}, drawn: 𝓛[ty]8655{Number}, lost: 𝓛[ty]8655{Number}, incomplete: 𝓛[ty]8655{Number}}, _id: 𝓛[ty]10051{String}, sessions: 𝓛[ty]8670{Array}, fullname: 𝓛[ty]10051{String}, pending_messages: 𝓛[ty]8670{Array}, friends: 𝓛[ty]8670{Array}, skill: {trend: 𝓛[ty]8655{Number}, next_level: 𝓛[ty]8655{Number}, matchmaking: 𝓛[ty]8655{Number}, xp: 𝓛[ty]8655{Number}, current_level: 𝓛[ty]8655{Number}, level: 𝓛[ty]8655{Number}}, type: 𝓛[ty]10051{String}, friend_requests: 𝓛[ty]8670{Array}, last_seen: 𝓛[ty]8635{Date}, password: 𝓛[ty]10051{String}}
let 𝓟440{settings}: [OOV]any = {};
function 𝓟441{CONSTRUCTOR} (): (𝓟[ty]449{User})
{
const 𝓟[ty]449{User};
const 𝓟[ty]449{User};
}
function 𝓟445{onCreating} (𝓟446{user}: [OOV]𝓟[ty]439{UserDocument}): (𝓟447: [OOV]any)
{
let 𝓟448{passwordTest}: [miss]𝓛[ty]8662{RegExp} = 𝓛8748{RegExp};
if (𝓛12569{ExclamationToken}(𝓟448{passwordTest}.test(𝓛12546{BarBarToken}(𝓟446{user}.password,𝓛8743{String}))))
{
return 𝓟447 = 𝓟1681{Promise}.reject(𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}))
}
𝓟446{user}.password ⟵ 𝓛10097{require}(𝓛8743{String}).createHash(𝓛8743{String}).update(𝓟440{settings}.security.salt).update(𝓟446{user}.password).digest(𝓛8743{String});
𝓟1680{_}.defaults(𝓟446{user},{banned: 𝓛8744{Boolean},statistics: {won: 𝓛8745{Number},drawn: 𝓛8745{Number},lost: 𝓛8745{Number},incomplete: 𝓛8745{Number}},sessions: 𝓛8757{Array}(),pending_messages: 𝓛8757{Array}(),friends: 𝓛8757{Array}(),skill: {trend: 𝓛8745{Number},next_level: 𝓛8745{Number},matchmaking: 𝓛8745{Number},xp: 𝓛8745{Number},current_level: 𝓛8745{Number},level: 𝓛8745{Number}},type: 𝓛8743{String},friend_requests: 𝓛8757{Array}(),last_seen: 𝓛8747{Date}.CONSTRUCTOR()})
}
class 𝓟[ty]449{User} extends 𝓛[ty]2{<UNKNOWN>} with 𝓟[ty]439{UserDocument}{
𝓟451{banned}: 𝓛[ty]8666{Boolean};
𝓟452{email}: 𝓛[ty]10051{String};
𝓟453{statistics}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8642{Object});
𝓟454{_id}: 𝓛[ty]10051{String};
𝓟455{sessions}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
𝓟456{fullname}: 𝓛[ty]10051{String};
𝓟457{pending_messages}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
𝓟458{friends}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
𝓟459{skill}: (𝓟[ty]595{Omnom} ≠ 𝓛[ty]8642{Object});
𝓟460{type}: 𝓛[ty]10051{String};
𝓟461{friend_requests}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8670{Array});
𝓟462{last_seen}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8635{Date});
𝓟463{password}: 𝓛[ty]10051{String};
function 𝓟479{addFriend} (𝓟480{friend}: 𝓛[ty]10051{String},𝓟481{callback}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟482: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]449{User}.save({$push: {friends: 𝓟480{friend}}},𝓟481{callback})
}
function 𝓟464{username} (): (𝓟465)
{
return 𝓟465 = 𝓟[ty]449{User}._id
}
function 𝓟469{setPassword} (𝓟470{newPassword}: 𝓛[ty]10051{String},𝓟471{callback}: 𝓛[ty]8696{Function}): (𝓟472: [miss]𝓛[ty]10033{Void})
{
let 𝓟473{passwordTest}: [miss]𝓛[ty]8662{RegExp} = 𝓛8748{RegExp};
if (𝓛12569{ExclamationToken}(𝓟473{passwordTest}.test(𝓛12546{BarBarToken}(𝓟470{newPassword},𝓛8743{String}))))
{
return 𝓟472 = 𝓟471{callback}(𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}))
}
let 𝓟474{hashed} = 𝓛10097{require}(𝓛8743{String}).createHash(𝓛8743{String}).update(𝓟440{settings}.security.salt).update(𝓟470{newPassword}).digest(𝓛8743{String});
𝓟[ty]449{User}.password ⟵ 𝓟474{hashed};
𝓟[ty]449{User}.save(𝓟471{callback})
}
function 𝓟483{updateLevel} (): (𝓟484: [miss]𝓛[ty]10033{Void})
{
let 𝓟485{remainingXP}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]449{User}.skill.xp;
let 𝓟486{previousLevelXP}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
let 𝓟487{levelXP}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
let 𝓟488{level}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
{
while (𝓛12596{GreaterThanEqualsToken}(𝓟485{remainingXP},𝓟487{levelXP}))
{
𝓛1{<UNKNOWN>}(𝓛1{<UNKNOWN>}(𝓛1{<UNKNOWN>}(𝓛12556{POST_PlusPlusToken}(𝓟488{level}),𝓛1{<UNKNOWN>}(𝓟486{previousLevelXP},𝓟487{levelXP})),𝓛12606{MinusEqualsToken}(𝓟485{remainingXP},𝓟487{levelXP})),𝓛12564{FirstCompoundAssignment}(𝓟487{levelXP},𝓛12548{AsteriskToken}(𝓛8745{Number},𝓛8746{Math}.pow(𝓛8745{Number},𝓟488{level}))))
}
}
𝓟[ty]449{User}.skill.level ⟵ 𝓟488{level};
𝓟[ty]449{User}.skill.current_level ⟵ 𝓟486{previousLevelXP};
𝓟[ty]449{User}.skill.next_level ⟵ 𝓟487{levelXP};
}
function 𝓟466{API} (): (𝓟467)
{
let 𝓟468{$} = 𝓟[ty]449{User};
return 𝓟467 = {banned: 𝓟468{$}.banned,email: 𝓟468{$}.email,statistics: 𝓟468{$}.statistics,username: 𝓟468{$}.username,fullname: 𝓟468{$}.fullname,pending_messages: 𝓟468{$}.pending_messages,friends: 𝓟468{$}.friends,skill: {level: 𝓟468{$}.skill.level,xp: 𝓟468{$}.skill.xp},last_seen: 𝓟468{$}.last_seen}
}
function 𝓟475{checkPassword} (𝓟476{password}: 𝓛[ty]10051{String}): (𝓟477: 𝓛[ty]8666{Boolean})
{
let 𝓟478{hashed} = 𝓛10097{require}(𝓛8743{String}).createHash(𝓛8743{String}).update(𝓟440{settings}.security.salt).update(𝓟476{password}).digest(𝓛8743{String});
return 𝓟477 = 𝓛12599{EqualsEqualsToken}(𝓟478{hashed},𝓟[ty]449{User}.password)
}
}
function 𝓟489{CONSTRUCTOR} (): (𝓟[ty]493{Core})
{
const 𝓟[ty]493{Core};
const 𝓟[ty]493{Core};
𝓟[ty]493{Core}.Users ⟵ 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟[ty]493{Core},𝓛12643{undefined});
}
class 𝓟[ty]493{Core} extends 𝓛[ty]2{<UNKNOWN>}{
𝓟495{Users}: [OOV]𝓛[ty]2{<UNKNOWN>};
}
let 𝓟496{core}: [miss]𝓟[ty]493{Core} = 𝓟489{CONSTRUCTOR}(𝓛8743{String});
function 𝓟497{$Lambda60} (𝓟498{user}): (𝓟499: [miss]𝓛[ty]8666{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟498{user}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
if (𝓟498{user}.checkPassword(𝓛8743{String}))
{
return 𝓟499 = 𝓛8744{Boolean}
}
return 𝓟499 = 𝓛8744{Boolean}
}
𝓟496{core}.Users.findOne().then(𝓟497{$Lambda60})
Module: lib/CacheDirector
type 𝓟[ty]500{CacheDirector} = {valid: (any)->𝓛[ty]8666{Boolean}, buildKey: (any)->𝓛[ty]10051{String}, validQuery: (any)->𝓛[ty]8666{Boolean}, buildQueryKey: (any)->𝓛[ty]10051{String}}
Module: lib/Schema
type 𝓟[ty]501{Schema} = {_id: any, access: (𝓛[ty]10051{String})->any}
Module: lib/ModelInterfaces
type 𝓟[ty]502{ModelSpecificInstanceConstructor} = {CONSTRUCTOR: (any,𝓛[ty]8666{Boolean},𝓛[ty]8666{Boolean})->any}
Module: example/ValidationPlugin
function 𝓟503{CONSTRUCTOR} (): (𝓟[ty]523{StringCaseValidationPlugin})
{
const 𝓟[ty]523{StringCaseValidationPlugin};
const 𝓟[ty]523{StringCaseValidationPlugin};
function 𝓟507{$Lambda61} (𝓟508{schema}): (𝓟509: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟509 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟508{schema},𝓛8743{String})
}
function 𝓟510{$Lambda62} (𝓟511{schema},𝓟512{data},𝓟513{path}): (𝓟514: [OOV]any)
{
return 𝓟514 = 𝓟[ty]523{StringCaseValidationPlugin}.assert(𝓛12599{EqualsEqualsToken}(𝓟512{data}.toLowerCase(),𝓟512{data}))
}
function 𝓟515{$Lambda63} (𝓟516{schema}): (𝓟517: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟517 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟516{schema},𝓛8743{String})
}
function 𝓟518{$Lambda64} (𝓟519{schema},𝓟520{data},𝓟521{path}): (𝓟522: [OOV]any)
{
return 𝓟522 = 𝓟[ty]523{StringCaseValidationPlugin}.assert(𝓛12599{EqualsEqualsToken}(𝓟520{data}.toUpperCase(),𝓟520{data}))
}
𝓟[ty]523{StringCaseValidationPlugin}.validate ⟵ 𝓛8757{Array}(𝓟1682{Skmatc}.create(𝓟507{$Lambda61},𝓟510{$Lambda62}),𝓟1682{Skmatc}.create(𝓟515{$Lambda63},𝓟518{$Lambda64}));
}
class 𝓟[ty]523{StringCaseValidationPlugin} extends 𝓛[ty]2{<UNKNOWN>}{
𝓟525{validate}: [miss]𝓛[ty]8670{Array};
}
Module: lib/cacheControllers/IDDirector
function 𝓟526{CONSTRUCTOR} (): (𝓟[ty]530{CacheOnID})
{
const 𝓟[ty]530{CacheOnID};
const 𝓟[ty]530{CacheOnID};
}
class 𝓟[ty]530{CacheOnID} extends 𝓟[ty]500{CacheDirector}{
function 𝓟532{valid} (𝓟533{object}: 𝓛[ty]8642{Object}): (𝓟534: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟534 = 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟533{object}._id))
}
function 𝓟535{buildKey} (𝓟536{object}: 𝓛[ty]8642{Object}): (𝓟537: [OOV]any)
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟536{object}._id._bsontype,𝓛8743{String}))
{
return 𝓟537 = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟536{object}._id.id).toHexString()
}
return 𝓟537 = 𝓟536{object}._id
}
function 𝓟538{validQuery} (𝓟539{conditions}: 𝓛[ty]8642{Object}): (𝓟540: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟540 = 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟539{conditions}._id))
}
function 𝓟541{buildQueryKey} (𝓟542{conditions}: (𝓟[ty]794{User} ≠ 𝓛[ty]8642{Object})): (𝓟543: [OOV]any)
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟542{conditions}._id._bsontype,𝓛8743{String}))
{
return 𝓟543 = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟542{conditions}._id.id).toHexString()
}
return 𝓟543 = 𝓟542{conditions}._id
}
}
Module: lib/utils/ObjectID
function 𝓟544{toObjectID} (𝓟545{value}: 𝓛[ty]10051{String}): (𝓟546: [OOV]𝓛[ty]2{<UNKNOWN>})
{
return 𝓟546 = 𝓛1{<UNKNOWN>}.createFromHexString(𝓟545{value})
}
Module: lib/Changes
type 𝓟[ty]564{Changes} = {$mul: {access: (𝓛[ty]10051{String})->𝓛[ty]8655{Number}}, $currentDate: {access: (𝓛[ty]10051{String})->any}, $min: {access: (𝓛[ty]10051{String})->𝓛[ty]8655{Number}}, $rename: {access: (𝓛[ty]10051{String})->𝓛[ty]10051{String}}, $pull: {access: (𝓛[ty]10051{String})->𝓟[ty]1387{Conditions}}, $unset: {access: (𝓛[ty]10051{String})->𝓛[ty]8666{Boolean}}, $set: 𝓟[ty]375{BSONObject}, $push: {access: (𝓛[ty]10051{String})->any}, $inc: {access: (𝓛[ty]10051{String})->𝓛[ty]8655{Number}}, $pullAll: {access: (𝓛[ty]10051{String})->𝓛[ty]8670{Array}}, $max: {access: (𝓛[ty]10051{String})->𝓛[ty]8655{Number}}, $addToSet: {access: (𝓛[ty]10051{String})->any}, $bit: {access: (𝓛[ty]10051{String})->any}}
Module: lib/utils/Omnom
function 𝓟565{CONSTRUCTOR} (𝓟566{options}: (𝓛[ty]10921{HTMLElement} ≠ 𝓛[ty]8642{Object})): (𝓟[ty]595{Omnom})
{
const 𝓟[ty]595{Omnom};
const 𝓟[ty]595{Omnom};
𝓟[ty]595{Omnom}.options ⟵ 𝓟566{options};
𝓟[ty]595{Omnom}._changes ⟵ {};
}
function 𝓟570{diff} (𝓟571{original}: (𝓟[ty]552{ModelCache} ≠ 𝓛[ty]8655{Number}),𝓟572{modified}: (𝓟[ty]552{ModelCache} ≠ 𝓛[ty]8655{Number}),𝓟573{options}: 𝓛[ty]8642{Object}): (𝓟574: [OOV]𝓟[ty]564{Changes})
{
}
function 𝓟575{diff} (𝓟576{original}: (𝓟[ty]552{ModelCache} ≠ 𝓛[ty]8670{Array}),𝓟577{modified}: (𝓟[ty]552{ModelCache} ≠ 𝓛[ty]8670{Array}),𝓟578{options}: 𝓛[ty]8642{Object}): (𝓟579: [OOV]𝓟[ty]564{Changes})
{
}
function 𝓟580{diff} (𝓟581{original}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟582{modified}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟583{options}: 𝓛[ty]8642{Object}): (𝓟584: [OOV]𝓟[ty]564{Changes})
{
}
function 𝓟585{diff} (𝓟586{original}: (𝓟[ty]552{ModelCache} ≠ 𝓛[ty]8642{Object}),𝓟587{modified}: (𝓟[ty]552{ModelCache} ≠ 𝓛[ty]8642{Object}),𝓟588{options}: 𝓛[ty]8642{Object}): (𝓟589: [OOV]𝓟[ty]564{Changes})
{
}
function 𝓟590{diff} (𝓟591{original}: [OOV]any,𝓟592{modified}: [OOV]any,𝓟593{options}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8642{Object})): (𝓟594: [OOV]𝓟[ty]564{Changes})
{
return 𝓟594 = 𝓟565{CONSTRUCTOR}(𝓟593{options}).diff(𝓟591{original},𝓟592{modified}).changes
}
class 𝓟[ty]595{Omnom}{
𝓟597{options}: (𝓛[ty]10921{HTMLElement} ≠ 𝓛[ty]8642{Object});
𝓟598{_changes}: [OOV]𝓟[ty]564{Changes};
function 𝓟651{onNumber} (𝓟652{original}: 𝓛[ty]8655{Number},𝓟653{modified}: 𝓛[ty]8655{Number},𝓟654{changePath}: 𝓛[ty]10051{String}): (𝓟655: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10033{Void}))
{
if (𝓛12599{EqualsEqualsToken}(𝓟652{original},𝓟653{modified}))
{
}
if (𝓟[ty]595{Omnom}.options.atomicNumbers)
{
return 𝓟655 = 𝓟[ty]595{Omnom}.inc(𝓟654{changePath},𝓛12616{MinusToken}(𝓟653{modified},𝓟652{original}))
}
return 𝓟655 = 𝓟[ty]595{Omnom}.set(𝓟654{changePath},𝓟653{modified})
}
function 𝓟696{onLargerArray} (𝓟697{original}: 𝓛[ty]8670{Array},𝓟698{modified}: 𝓛[ty]8670{Array},𝓟699{changePath}: 𝓛[ty]10051{String}): (𝓟700: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10033{Void}))
{
let 𝓟701{canPush}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
{
let 𝓟702{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟702{i},𝓟697{original}.length))
{
if (𝓛1{<UNKNOWN>}(𝓟[ty]595{Omnom}.almostEqual(𝓟697{original}.access(𝓟702{i}),𝓟698{modified}.access(𝓟702{i})),𝓛8745{Number}))
{
𝓟701{canPush} ⟵ 𝓛8744{Boolean};
}
𝓛12556{POST_PlusPlusToken}(𝓟702{i})
}
}
if (𝓟701{canPush})
{
{
let 𝓟703{i}: [miss]𝓛[ty]8655{Number} = 𝓟697{original}.length;
while (𝓛1{<UNKNOWN>}(𝓟703{i},𝓟698{modified}.length))
{
𝓟[ty]595{Omnom}.push(𝓟699{changePath},𝓟698{modified}.access(𝓟703{i}))
𝓛12556{POST_PlusPlusToken}(𝓟703{i})
}
}
}
return 𝓟700 = 𝓟[ty]595{Omnom}.onSimilarArray(𝓟697{original},𝓟698{modified},𝓟699{changePath})
}
function 𝓟641{onSomething} (𝓟642{original}: [OOV]any,𝓟643{modified}: [OOV]any,𝓟644{changePath}: 𝓛[ty]10051{String}): (𝓟645: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10033{Void}))
{
if (𝓟644{changePath})
{
if (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟642{original},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓟642{original},𝓛12643{undefined})))
{
return 𝓟645 = 𝓟[ty]595{Omnom}.onUndefined(𝓟642{original},𝓟643{modified},𝓟644{changePath})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟642{original}),𝓛8743{String}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟643{modified}),𝓛8743{String})))
{
return 𝓟645 = 𝓟[ty]595{Omnom}.onNumber(𝓟642{original},𝓟643{modified},𝓟644{changePath})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛8757{Array}.isArray(𝓟642{original}),𝓛8757{Array}.isArray(𝓟643{modified})))
{
return 𝓟645 = 𝓟[ty]595{Omnom}.onArray(𝓟642{original},𝓟643{modified},𝓟644{changePath})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛1{<UNKNOWN>}(𝓟642{original},𝓛1{<UNKNOWN>}),𝓛1{<UNKNOWN>}(𝓟643{modified},𝓛1{<UNKNOWN>})))
{
return 𝓟645 = 𝓟[ty]595{Omnom}.onObjectID(𝓟642{original},𝓟643{modified},𝓟644{changePath})
}
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟642{original})),𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟643{modified}))))
{
return 𝓟645 = 𝓟[ty]595{Omnom}.onScalar(𝓟642{original},𝓟643{modified},𝓟644{changePath})
}
}
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟642{original})),𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟643{modified}))))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
return 𝓟645 = 𝓟[ty]595{Omnom}.onObject(𝓟642{original},𝓟643{modified},𝓟644{changePath})
}
function 𝓟646{onUndefined} (𝓟647{original}: [OOV]any,𝓟648{modified}: [OOV]any,𝓟649{changePath}: 𝓛[ty]10051{String}): (𝓟650: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10033{Void}))
{
return 𝓟650 = 𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟647{original},𝓟648{modified}) as any,𝓟[ty]595{Omnom}.set(𝓟649{changePath},𝓟648{modified}))
}
function 𝓟719{unset} (𝓟720{path}: 𝓛[ty]10051{String}): (𝓟721: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]595{Omnom}.changes.$unset))
{
𝓟[ty]595{Omnom}.changes.$unset ⟵ {};
}
𝓟[ty]595{Omnom}.changes.$unset.access(𝓟720{path}) ⟵ 𝓛8744{Boolean};
}
function 𝓟715{set} (𝓟716{path}: 𝓛[ty]10051{String},𝓟717{value}: [OOV]any): (𝓟718: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]595{Omnom}.changes.$set))
{
𝓟[ty]595{Omnom}.changes.$set ⟵ {};
}
𝓟[ty]595{Omnom}.changes.$set.access(𝓟716{path}) ⟵ 𝓟717{value};
}
function 𝓟726{push} (𝓟727{path}: 𝓛[ty]10051{String},𝓟728{value}: [OOV]any): (𝓟729: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]595{Omnom}.changes.$push))
{
𝓟[ty]595{Omnom}.changes.$push ⟵ {};
}
if (𝓟[ty]595{Omnom}.changes.$push.access(𝓟727{path}))
{
const 𝓟730{change}: [miss]𝓛[ty]8642{Object} = 𝓟[ty]595{Omnom}.changes.$push.access(𝓟727{path}) as {$each: 𝓛[ty]8670{Array}};
if (𝓛12592{AmpersandAmpersandToken}(𝓟730{change},𝓟730{change}.$each))
{
𝓟730{change}.$each.push(𝓟728{value})
}
else
{
𝓟[ty]595{Omnom}.changes.$push.access(𝓟727{path}) ⟵ {$each: 𝓛8757{Array}(𝓟730{change},𝓟728{value})};
}
}
else
{
𝓟[ty]595{Omnom}.changes.$push.access(𝓟727{path}) ⟵ 𝓟728{value};
}
}
function 𝓟684{onSmallerArray} (𝓟685{original}: 𝓛[ty]8670{Array},𝓟686{modified}: 𝓛[ty]8670{Array},𝓟687{changePath}: 𝓛[ty]10051{String}): (𝓟688: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10033{Void}))
{
let 𝓟689{pulls}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
let 𝓟690{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
let 𝓟691{j}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
{
while (𝓛12592{AmpersandAmpersandToken}(𝓛1{<UNKNOWN>}(𝓟690{i},𝓟685{original}.length),𝓛1{<UNKNOWN>}(𝓟691{j},𝓟686{modified}.length)))
{
{
const 𝓟692{equalityDistance}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]595{Omnom}.almostEqual(𝓟685{original}.access(𝓟690{i}),𝓟686{modified}.access(𝓟691{j}));
if (𝓛12599{EqualsEqualsToken}(𝓟692{equalityDistance},𝓛8745{Number}))
{
𝓛12556{POST_PlusPlusToken}(𝓟691{j})
}
else
{
if (𝓛12595{GreaterThanToken}(𝓟692{equalityDistance},𝓛8745{Number}))
{
return 𝓟688 = 𝓟[ty]595{Omnom}.set(𝓟687{changePath},𝓟686{modified})
}
else
{
𝓟689{pulls}.push(𝓟685{original}.access(𝓟690{i}))
}
}
}
𝓛12556{POST_PlusPlusToken}(𝓟690{i})
}
}
{
while (𝓛1{<UNKNOWN>}(𝓟690{i},𝓟685{original}.length))
{
𝓟689{pulls}.push(𝓟685{original}.access(𝓟690{i}))
𝓛12556{POST_PlusPlusToken}(𝓟690{i})
}
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟691{j},𝓟686{modified}.length))
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟689{pulls}.length,𝓛8745{Number}))
{
return 𝓟688 = 𝓟[ty]595{Omnom}.pull(𝓟687{changePath},𝓟689{pulls}.access(𝓛8745{Number}))
}
function 𝓟693{$Lambda202} (𝓟694{pull}): (𝓟695: [miss]𝓛[ty]10033{Void})
{
return 𝓟695 = 𝓟[ty]595{Omnom}.pull(𝓟687{changePath},𝓟694{pull})
}
return 𝓟688 = 𝓟689{pulls}.forEach(𝓟693{$Lambda202})
}
return 𝓟688 = 𝓟[ty]595{Omnom}.set(𝓟687{changePath},𝓟686{modified})
}
function 𝓟599{changes} (): (𝓟600: [OOV]𝓟[ty]564{Changes})
{
return 𝓟600 = 𝓟[ty]595{Omnom}._changes
}
function 𝓟704{onSimilarArray} (𝓟705{original}: 𝓛[ty]8670{Array},𝓟706{modified}: 𝓛[ty]8670{Array},𝓟707{changePath}: 𝓛[ty]10051{String}): (𝓟708: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10033{Void}))
{
let 𝓟709{sets}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
let 𝓟710{partials}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
{
let 𝓟711{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟711{i},𝓟706{modified}.length))
{
{
let 𝓟712{equality}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]595{Omnom}.almostEqual(𝓟705{original}.access(𝓟711{i}),𝓟706{modified}.access(𝓟711{i}));
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟712{equality},𝓛8745{Number}))
{
𝓟709{sets}.push(𝓟711{i})
}
else
{
if (𝓛1{<UNKNOWN>}(𝓟712{equality},𝓛8745{Number}))
{
𝓟710{partials}.push(𝓟711{i})
}
}
}
𝓛12556{POST_PlusPlusToken}(𝓟711{i})
}
}
if (𝓛12595{GreaterThanToken}(𝓟709{sets}.length,𝓛12573{SlashToken}(𝓟706{modified}.length,𝓛8745{Number})))
{
return 𝓟708 = 𝓟[ty]595{Omnom}.set(𝓟707{changePath},𝓟706{modified})
}
{
let 𝓟713{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟713{i},𝓟709{sets}.length))
{
𝓟[ty]595{Omnom}.set(𝓟[ty]595{Omnom}.resolve(𝓟707{changePath},𝓟709{sets}.access(𝓟713{i}).toString()),𝓟706{modified}.access(𝓟709{sets}.access(𝓟713{i})))
𝓛12556{POST_PlusPlusToken}(𝓟713{i})
}
}
{
let 𝓟714{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟714{i},𝓟710{partials}.length))
{
𝓟[ty]595{Omnom}.onSomething(𝓟705{original}.access(𝓟710{partials}.access(𝓟714{i})),𝓟706{modified}.access(𝓟710{partials}.access(𝓟714{i})),𝓟[ty]595{Omnom}.resolve(𝓟707{changePath},𝓟710{partials}.access(𝓟714{i}).toString()))
𝓛12556{POST_PlusPlusToken}(𝓟714{i})
}
}
}
function 𝓟750{almostEqual} (𝓟751{o1}: [OOV]any,𝓟752{o2}: [OOV]any): (𝓟753: 𝓛[ty]8655{Number})
{
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟751{o1})),𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟752{o2}))))
{
return 𝓟753 = (𝓛12599{EqualsEqualsToken}(𝓟751{o1},𝓟752{o2}) ? 𝓛8745{Number} : 𝓛8745{Number}
}
let 𝓟754{object1Keys}: [miss]𝓛[ty]8670{Array} = 𝓛8741{Object}.keys(𝓟751{o1});
let 𝓟755{object2Keys}: [miss]𝓛[ty]8670{Array} = 𝓛8741{Object}.keys(𝓟752{o2});
let 𝓟756{commonKeys}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
{
let 𝓟757{object1KeyIndex}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟757{object1KeyIndex},𝓟754{object1Keys}.length))
{
if (𝓛12621{TildeToken}(𝓟755{object2Keys}.indexOf(𝓟754{object1Keys}.access(𝓟757{object1KeyIndex}))))
{
𝓟756{commonKeys}.push(𝓟754{object1Keys}.access(𝓟757{object1KeyIndex}))
}
𝓛12556{POST_PlusPlusToken}(𝓟757{object1KeyIndex})
}
}
let 𝓟758{totalKeys}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓛12641{PlusToken}(𝓟754{object1Keys}.length,𝓟755{object2Keys}.length),𝓟756{commonKeys}.length);
let 𝓟759{keysDifference}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟758{totalKeys},𝓟756{commonKeys}.length);
let 𝓟760{requiredChanges}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
{
let 𝓟761{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟761{i},𝓟756{commonKeys}.length))
{
if (𝓛1{<UNKNOWN>}(𝓟[ty]595{Omnom}.almostEqual(𝓟751{o1}.access(𝓟756{commonKeys}.access(𝓟761{i})),𝓟752{o2}.access(𝓟756{commonKeys}.access(𝓟761{i}))),𝓛8745{Number}))
{
𝓛12556{POST_PlusPlusToken}(𝓟760{requiredChanges})
}
𝓛12556{POST_PlusPlusToken}(𝓟761{i})
}
}
return 𝓟753 = 𝓛12616{MinusToken}(𝓛12616{MinusToken}(𝓛8745{Number},𝓛12573{SlashToken}(𝓟759{keysDifference},𝓟758{totalKeys})),𝓛12573{SlashToken}(𝓟760{requiredChanges},𝓟756{commonKeys}.length))
}
function 𝓟679{onArray} (𝓟680{original}: 𝓛[ty]8670{Array},𝓟681{modified}: 𝓛[ty]8670{Array},𝓟682{changePath}: 𝓛[ty]10051{String}): (𝓟683: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10033{Void}))
{
if (𝓛12595{GreaterThanToken}(𝓟680{original}.length,𝓟681{modified}.length))
{
return 𝓟683 = 𝓟[ty]595{Omnom}.onSmallerArray(𝓟680{original},𝓟681{modified},𝓟682{changePath})
}
if (𝓛1{<UNKNOWN>}(𝓟680{original}.length,𝓟681{modified}.length))
{
return 𝓟683 = 𝓟[ty]595{Omnom}.onLargerArray(𝓟680{original},𝓟681{modified},𝓟682{changePath})
}
return 𝓟683 = 𝓟[ty]595{Omnom}.onSimilarArray(𝓟680{original},𝓟681{modified},𝓟682{changePath})
}
function 𝓟617{diff} (𝓟618{original}: [OOV]any,𝓟619{modified}: [OOV]any): (𝓟620: 𝓟[ty]595{Omnom})
{
𝓟[ty]595{Omnom}.onSomething(𝓟618{original},𝓟619{modified})
return 𝓟620 = 𝓟[ty]595{Omnom}
}
function 𝓟735{pullAll} (𝓟736{path}: 𝓛[ty]10051{String},𝓟737{values}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]8670{Array})): (𝓟738: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]595{Omnom}.changes.$pullAll))
{
𝓟[ty]595{Omnom}.changes.$pullAll ⟵ {};
}
𝓟[ty]595{Omnom}.changes.$pullAll.access(𝓟736{path}) ⟵ 𝓟737{values};
}
function 𝓟739{resolve} (𝓟740{args}: (𝓟[ty]386{Core} ≠ 𝓛[ty]8670{Array})): (𝓟741: [miss]𝓛[ty]10051{String})
{
let 𝓟742{validArguments}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
function 𝓟743{$Lambda203} (𝓟744{arg}): (𝓟745: [miss]𝓛[ty]10033{Void})
{
if (𝓟744{arg})
{
𝓟742{validArguments}.push(𝓟744{arg})
}
}
𝓟740{args}.forEach(𝓟743{$Lambda203})
return 𝓟741 = 𝓟742{validArguments}.join(𝓛8743{String})
}
function 𝓟722{inc} (𝓟723{path}: 𝓛[ty]10051{String},𝓟724{value}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟725: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]595{Omnom}.changes.$inc))
{
𝓟[ty]595{Omnom}.changes.$inc ⟵ {};
}
𝓟[ty]595{Omnom}.changes.$inc.access(𝓟723{path}) ⟵ 𝓟724{value};
}
function 𝓟731{pull} (𝓟732{path}: 𝓛[ty]10051{String},𝓟733{value}: [OOV]any): (𝓟734: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]595{Omnom}.changes.$pull))
{
𝓟[ty]595{Omnom}.changes.$pull ⟵ {};
}
if (𝓛12592{AmpersandAmpersandToken}(𝓟[ty]595{Omnom}.changes.$pullAll,𝓟[ty]595{Omnom}.changes.$pullAll.access(𝓟732{path})))
{
𝓟[ty]595{Omnom}.changes.$pullAll.access(𝓟732{path}).push(𝓟733{value})
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛1{<UNKNOWN>}(𝓟[ty]595{Omnom}.changes.$pull).length,𝓛8745{Number}))
{
𝓛12622{$Delete}(𝓟[ty]595{Omnom}.changes.$pull)
}
}
if (𝓟[ty]595{Omnom}.changes.$pull.access(𝓟732{path}))
{
𝓟[ty]595{Omnom}.pullAll(𝓟732{path},𝓛8757{Array}(𝓟[ty]595{Omnom}.changes.$pull.access(𝓟732{path}),𝓟733{value}))
𝓛12622{$Delete}(𝓟[ty]595{Omnom}.changes.$pull.access(𝓟732{path}))
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛1{<UNKNOWN>}(𝓟[ty]595{Omnom}.changes.$pull).length,𝓛8745{Number}))
{
𝓛12622{$Delete}(𝓟[ty]595{Omnom}.changes.$pull)
}
}
𝓟[ty]595{Omnom}.changes.$pull.access(𝓟732{path}) ⟵ 𝓟733{value};
}
function 𝓟666{onObject} (𝓟667{original}: 𝓛[ty]8642{Object},𝓟668{modified}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8642{Object}),𝓟669{changePath}: 𝓛[ty]10051{String}): (𝓟670: 𝓛[ty]10033{Void})
{
function 𝓟671{$Lambda200} (𝓟672{value},𝓟673{key}): (𝓟674: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟673{key}))
{
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛8757{Array}.isArray(𝓟672{value}),𝓛8757{Array}.isArray(𝓟667{original}.access(𝓟673{key}))))
{
𝓟[ty]595{Omnom}.onArray(𝓟667{original}.access(𝓟673{key}),𝓟672{value},𝓟[ty]595{Omnom}.resolve(𝓟669{changePath},𝓟673{key}))
}
else
{
𝓟[ty]595{Omnom}.onSomething(𝓟667{original}.access(𝓟673{key}),𝓟672{value},𝓟[ty]595{Omnom}.resolve(𝓟669{changePath},𝓟673{key}))
}
}
𝓛1{<UNKNOWN>}(𝓟668{modified},𝓟671{$Lambda200})
function 𝓟675{$Lambda201} (𝓟676{value},𝓟677{key}): (𝓟678: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟677{key}))
{
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟668{modified}.access(𝓟677{key}),𝓛12643{undefined}))
{
return 𝓟678 = 𝓟[ty]595{Omnom}.unset(𝓟[ty]595{Omnom}.resolve(𝓟669{changePath},𝓟677{key}))
}
}
𝓛1{<UNKNOWN>}(𝓟667{original},𝓟675{$Lambda201})
}
function 𝓟656{onObjectID} (𝓟657{original}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟658{modified}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟659{changePath}: 𝓛[ty]10051{String}): (𝓟660: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10033{Void}))
{
return 𝓟660 = 𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟657{original}.equals(𝓟658{modified})) as any,𝓟[ty]595{Omnom}.set(𝓟659{changePath},𝓟658{modified}))
}
function 𝓟661{onScalar} (𝓟662{original}: [OOV]any,𝓟663{modified}: [OOV]any,𝓟664{changePath}: 𝓛[ty]10051{String}): (𝓟665: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10033{Void}))
{
return 𝓟665 = 𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟662{original},𝓟663{modified})) as any,𝓟[ty]595{Omnom}.set(𝓟664{changePath},𝓟663{modified}))
}
}
Module: lib/MapReduce
type 𝓟[ty]762{MapReducedDocument} = {_id: any, value: any}
type 𝓟[ty]763{MapReduceOptions} extends 𝓛[ty]2{<UNKNOWN>} = {out: any}
type 𝓟[ty]764{MapReduceFunctions} = {map: 𝓟[ty]765{MapFunction}, reduce: 𝓟[ty]766{ReduceFunction}}
type 𝓟[ty]765{MapFunction} = {call: (any)->𝓛[ty]10033{Void}}
type 𝓟[ty]766{ReduceFunction} = {call: (any,𝓛[ty]8670{Array})->any}
function 𝓟767{emit} (𝓟768{key}: [OOV]any,𝓟769{value}: [OOV]any): (𝓟770: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10033{Void}))
{
}
Module: lib/Transforms
type 𝓟[ty]771{PropertyTransform} = {fromDB: (any,𝓛[ty]10051{String},𝓟[ty]947{Model})->any, toDB: (any,𝓛[ty]10051{String},𝓟[ty]947{Model})->any}
type 𝓟[ty]772{Transforms} = {$document: 𝓟[ty]771{PropertyTransform}, _id: 𝓟[ty]771{PropertyTransform}, access: (𝓛[ty]10051{String})->any}
function 𝓟773{$Lambda189} (𝓟774{value}): (𝓟775: [OOV]any)
{
return 𝓟775 = (𝓛1{<UNKNOWN>}(𝓟774{value},𝓟1679{ObjectID}) ? 𝓟774{value}.toHexString() : 𝓟774{value}
}
function 𝓟776{$Lambda190} (𝓟777{value}): (𝓟778: [OOV]any)
{
return 𝓟778 = (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟777{value}),𝓛8743{String}) ? 𝓟1679{ObjectID}.CONSTRUCTOR(𝓟777{value}) : 𝓟777{value}
}
function 𝓟779{$Lambda191} (𝓟780{value}): (𝓟781: [OOV]any)
{
if (𝓛12569{ExclamationToken}(𝓟780{value}))
{
return 𝓟781 = 𝓛12643{undefined}
}
if (𝓛1{<UNKNOWN>}(𝓟780{value},𝓟1683{Binary}))
{
return 𝓟781 = 𝓟780{value} as any.buffer
}
return 𝓟781 = 𝓟780{value}
}
function 𝓟782{$Lambda192} (𝓟783{value}): (𝓟784: [OOV]any)
{
if (𝓛10100{Buffer}.isBuffer(𝓟783{value}))
{
return 𝓟784 = 𝓟1683{Binary}.CONSTRUCTOR(𝓟783{value})
}
if (𝓛8757{Array}.isArray(𝓟783{value}))
{
return 𝓟784 = 𝓟1683{Binary}.CONSTRUCTOR(𝓛10100{Buffer}.CONSTRUCTOR(𝓟783{value}))
}
return 𝓟784 = 𝓛12643{undefined}
}
const 𝓟785{DefaultTransforms}: [miss]𝓛[ty]8642{Object} = {ObjectID: {fromDB: 𝓟773{$Lambda189},toDB: 𝓟776{$Lambda190}} as 𝓟[ty]771{PropertyTransform},Binary: {fromDB: 𝓟779{$Lambda191},toDB: 𝓟782{$Lambda192}} as 𝓟[ty]771{PropertyTransform}};
Module: example/IntelliSense
type 𝓟[ty]786{UserDoc} = {email: 𝓛[ty]10051{String}, username: 𝓛[ty]10051{String}, _id: 𝓛[ty]10051{String}, passwordHash: 𝓛[ty]10051{String}, dateOfBirth: 𝓛[ty]8635{Date}, fullname: 𝓛[ty]10051{String}, joined: 𝓛[ty]8635{Date}}
function 𝓟787{CONSTRUCTOR} (): (𝓟[ty]794{User})
{
const 𝓟[ty]794{User};
const 𝓟[ty]794{User};
}
function 𝓟791{onCreating} (𝓟792{doc}: [OOV]𝓟[ty]786{UserDoc}): (𝓟793: [miss]𝓛[ty]10033{Void})
{
𝓟792{doc}.joined ⟵ 𝓛8747{Date}.CONSTRUCTOR();
}
class 𝓟[ty]794{User} extends 𝓛[ty]2{<UNKNOWN>} with 𝓟[ty]786{UserDoc}{
𝓟796{email}: 𝓛[ty]10051{String};
𝓟797{username}: 𝓛[ty]10051{String};
𝓟798{_id}: 𝓛[ty]10051{String};
𝓟799{passwordHash}: 𝓛[ty]10051{String};
𝓟800{dateOfBirth}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8635{Date});
𝓟801{fullname}: 𝓛[ty]10051{String};
𝓟802{joined}: (𝓛[ty]3199{Map} ≠ 𝓛[ty]8635{Date});
function 𝓟803{changePassword} (𝓟804{newPassword}: 𝓛[ty]10051{String}): (𝓟805: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]794{User}.passwordHash ⟵ 𝓟804{newPassword}.toLowerCase();
}
}
function 𝓟806{CONSTRUCTOR} (): (𝓟[ty]810{MyDB})
{
const 𝓟[ty]810{MyDB};
const 𝓟[ty]810{MyDB};
𝓟[ty]810{MyDB}.Users ⟵ 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟[ty]810{MyDB},𝓛12643{undefined});
}
class 𝓟[ty]810{MyDB} extends 𝓛[ty]2{<UNKNOWN>}{
𝓟812{Users}: [OOV]𝓛[ty]2{<UNKNOWN>};
}
let 𝓟813{db}: [miss]𝓟[ty]810{MyDB} = 𝓟806{CONSTRUCTOR}(𝓛8743{String});
function 𝓟814{$Lambda53} (): (𝓟815: [miss]𝓛[ty]10033{Void})
{
function 𝓟816{$Lambda54} (𝓟817{user}): (𝓟818: [miss]𝓛[ty]10033{Void})
{
𝓟817{user}.dateOfBirth.getTime()
}
𝓟813{db}.Users.insert({email: 𝓛8743{String},username: 𝓛8743{String},passwordHash: 𝓛8743{String},dateOfBirth: 𝓛8747{Date}.CONSTRUCTOR(),fullname: 𝓛8743{String}}).then(𝓟816{$Lambda54})
function 𝓟819{$Lambda55} (𝓟820{users}): (𝓟821: [miss]𝓛[ty]10033{Void})
{
𝓟820{users}.access(𝓛8745{Number}).fullname
}
𝓟813{db}.Users.insert(𝓛8757{Array}({email: 𝓛8743{String},username: 𝓛8743{String},passwordHash: 𝓛8743{String},dateOfBirth: 𝓛8747{Date}.CONSTRUCTOR(),fullname: 𝓛8743{String}})).then(𝓟819{$Lambda55})
function 𝓟822{$Lambda56} (𝓟823{user}): (𝓟824: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟823{user}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
function 𝓟825{$Lambda57} (𝓟826{user}): (𝓟827: [miss]𝓛[ty]10033{Void})
{
function 𝓟828{$Lambda58} (𝓟829{user}): (𝓟830: [OOV]any)
{
𝓟829{user}.username ⟵ 𝓛8743{String};
return 𝓟830 = 𝓟829{user}.save()
}
𝓟826{user}.remove().then(𝓟828{$Lambda58})
}
𝓟823{user}.save().then(𝓟825{$Lambda57})
}
𝓟813{db}.Users.findOne().then(𝓟822{$Lambda56})
function 𝓟831{$Lambda59} (𝓟832{count}): (𝓟833: [miss]𝓛[ty]10033{Void})
{
𝓟832{count}.toPrecision(𝓛8745{Number})
}
𝓟813{db}.Users.count().then(𝓟831{$Lambda59})
}
𝓟813{db}.connect().then(𝓟814{$Lambda53})
Module: lib/Decorators
function 𝓟834{Collection} (𝓟835{name}: 𝓛[ty]10051{String}): (𝓟836: [miss]𝓛[ty]8696{Function})
{
function 𝓟837{$Lambda96} (𝓟838{target}: [OOV]𝓟[ty]938{InstanceImplementation}): (𝓟839: [miss]𝓛[ty]10033{Void})
{
𝓟838{target}.collection ⟵ 𝓟835{name};
}
return 𝓟836 = 𝓟837{$Lambda96}
}
function 𝓟840{Index} (𝓟841{spec}: [OOV]𝓟[ty]937{IndexSpecification},𝓟842{options}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟843: [miss]𝓛[ty]8696{Function})
{
function 𝓟844{$Lambda97} (𝓟845{target}: [OOV]𝓟[ty]938{InstanceImplementation}): (𝓟846: [miss]𝓛[ty]10033{Void})
{
𝓟845{target}.indexes ⟵ 𝓛12546{BarBarToken}(𝓟845{target}.indexes,𝓛8757{Array}()).concat({spec: 𝓟841{spec},options: 𝓛12546{BarBarToken}(𝓟842{options},{})} as 𝓟[ty]936{Index});
}
return 𝓟843 = 𝓟844{$Lambda97}
}
function 𝓟847{Validate} (𝓟848{forType}: [OOV]any,𝓟849{validate}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟850: [miss]𝓛[ty]8696{Function})
{
function 𝓟851{$Lambda98} (𝓟852{target}: [OOV]𝓟[ty]938{InstanceImplementation}): (𝓟853: [miss]𝓛[ty]10033{Void})
{
function 𝓟854{$Lambda99} (𝓟855{schema}): (𝓟856: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟856 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟855{schema},𝓟848{forType})
}
𝓟852{target}.validators ⟵ 𝓛12546{BarBarToken}(𝓟852{target}.validators,𝓛8757{Array}()).concat(𝓛1{<UNKNOWN>}(𝓟854{$Lambda99},𝓟849{validate}));
}
return 𝓟850 = 𝓟851{$Lambda98}
}
function 𝓟857{Property} (𝓟858{asType}: [OOV]any,𝓟859{required}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8666{Boolean})): (𝓟860: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]8696{Function}))
{
}
function 𝓟861{Property} (𝓟862{name}: 𝓛[ty]10051{String},𝓟863{asType}: [OOV]any,𝓟864{required}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8666{Boolean})): (𝓟865: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]8696{Function}))
{
}
function 𝓟866{Property} (𝓟867{args}: 𝓛[ty]8670{Array}): (𝓟868: 𝓛[ty]8696{Function})
{
let 𝓟869{name}: [OOV]any = 𝓛12643{undefined};
let 𝓟870{asType}: [OOV]any = 𝓛8744{Boolean};
let 𝓟871{required}: 𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
if (𝓛12592{AmpersandAmpersandToken}(𝓛12595{GreaterThanToken}(𝓟867{args}.length,𝓛8745{Number}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟867{args}.access(𝓛12616{MinusToken}(𝓟867{args}.length,𝓛8745{Number}))),𝓛8743{String})))
{
𝓟871{required} ⟵ 𝓟867{args}.pop();
}
function 𝓟872{$Lambda100} (𝓟873{target}: [OOV]𝓟[ty]938{InstanceImplementation},𝓟874{property}: 𝓛[ty]10051{String}): (𝓟875: [miss]𝓛[ty]10033{Void})
{
let 𝓟876{staticTarget}: [OOV]𝓟[ty]938{InstanceImplementation} = 𝓟873{target};
if (𝓛12569{ExclamationToken}(𝓟874{property}))
{
𝓟869{name} ⟵ 𝓟867{args}.shift();
}
else
{
𝓟869{name} ⟵ 𝓟874{property};
𝓟876{staticTarget} ⟵ 𝓟873{target}.constructor as 𝓟[ty]938{InstanceImplementation};
}
𝓟870{asType} ⟵ 𝓛12546{BarBarToken}(𝓟867{args}.pop(),𝓛8744{Boolean});
𝓟876{staticTarget}.schema ⟵ 𝓛1{<UNKNOWN>}(𝓛12546{BarBarToken}(𝓟876{staticTarget}.schema,{_id: 𝓛8744{Boolean}}));
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟871{required}),𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟870{asType}),𝓛8743{String})))
{
𝓟876{staticTarget}.schema.access(𝓟869{name}) ⟵ {$required: 𝓟871{required},$type: 𝓟870{asType}};
}
else
{
𝓟876{staticTarget}.schema.access(𝓟869{name}) ⟵ 𝓟870{asType};
}
}
return 𝓟868 = 𝓟872{$Lambda100}
}
function 𝓟877{Transform} (𝓟878{fromDB}: 𝓛[ty]8696{Function},𝓟879{toDB}: 𝓛[ty]8696{Function}): (𝓟880: [miss]𝓛[ty]8696{Function})
{
function 𝓟881{$Lambda101} (𝓟882{target}: [OOV]any,𝓟883{property}: 𝓛[ty]10051{String}): (𝓟884: [miss]𝓛[ty]10033{Void})
{
let 𝓟885{staticTarget}: [OOV]𝓟[ty]938{InstanceImplementation} = 𝓛12546{BarBarToken}(𝓛12592{AmpersandAmpersandToken}(𝓛1{<UNKNOWN>}(𝓟882{target},𝓛12643{undefined}),𝓟882{target}.constructor),𝓟882{target}) as 𝓟[ty]938{InstanceImplementation};
𝓟885{staticTarget}.transforms ⟵ 𝓛1{<UNKNOWN>}(𝓛12546{BarBarToken}(𝓟885{staticTarget}.transforms,{} as 𝓟[ty]772{Transforms}));
𝓟885{staticTarget}.transforms.access(𝓟883{property}) ⟵ {fromDB: 𝓟878{fromDB},toDB: 𝓟879{toDB}};
}
return 𝓟880 = 𝓟881{$Lambda101}
}
function 𝓟886{ObjectID} (𝓟887{target}: (𝓛[ty]8642{Object} ≠ 𝓟[ty]32{Instance}),𝓟888{name}: 𝓛[ty]10051{String}): (𝓟889: [miss]𝓛[ty]10033{Void})
{
𝓟866{Property}(𝓛1{<UNKNOWN>})(𝓟887{target},𝓟888{name})
𝓟877{Transform}(𝓟785{DefaultTransforms}.ObjectID.fromDB,𝓟785{DefaultTransforms}.ObjectID.toDB)(𝓟887{target},𝓟888{name})
}
function 𝓟890{Binary} (𝓟891{target}: (𝓛[ty]8642{Object} ≠ 𝓟[ty]32{Instance}),𝓟892{name}: 𝓛[ty]10051{String}): (𝓟893: [miss]𝓛[ty]10033{Void})
{
𝓟866{Property}(𝓛10100{Buffer})(𝓟891{target},𝓟892{name})
𝓟877{Transform}(𝓟785{DefaultTransforms}.Binary.fromDB,𝓟785{DefaultTransforms}.Binary.toDB)(𝓟891{target},𝓟892{name})
}
function 𝓟894{MapReduce} (𝓟895{map}: [OOV]𝓟[ty]765{MapFunction},𝓟896{reduce}: [OOV]𝓟[ty]766{ReduceFunction}): (𝓟897: [miss]𝓛[ty]8696{Function})
{
function 𝓟898{$Lambda102} (𝓟899{target}: [OOV]𝓟[ty]938{InstanceImplementation}): (𝓟900: [miss]𝓛[ty]10033{Void})
{
𝓟899{target}.mapReduceOptions ⟵ {map: 𝓟895{map},reduce: 𝓟896{reduce}};
}
return 𝓟897 = 𝓟898{$Lambda102}
}
Module: lib/Aggregate
type 𝓟[ty]901{Stage} = {}
Module: lib/caches/NoOpCache
function 𝓟920{CONSTRUCTOR} (): (𝓟[ty]924{NoOpCache})
{
const 𝓟[ty]924{NoOpCache};
const 𝓟[ty]924{NoOpCache};
}
class 𝓟[ty]924{NoOpCache} extends 𝓟[ty]378{Cache}{
function 𝓟926{set} (𝓟927{key}: 𝓛[ty]10051{String},𝓟928{object}: [OOV]any): (𝓟929: [OOV]𝓛[ty]2{<UNKNOWN>})
{
return 𝓟929 = 𝓛23509{resolve}(𝓟928{object})
}
function 𝓟930{get} (𝓟931{key}: 𝓛[ty]10051{String}): (𝓟932: [OOV]𝓛[ty]2{<UNKNOWN>})
{
return 𝓟932 = 𝓛23509{resolve}()
}
function 𝓟933{clear} (𝓟934{key}: 𝓛[ty]10051{String}): (𝓟935: [OOV]𝓛[ty]2{<UNKNOWN>})
{
return 𝓟935 = 𝓛23509{resolve}(𝓛8744{Boolean})
}
}
Module: lib/Index
type 𝓟[ty]936{Index} = {spec: 𝓟[ty]937{IndexSpecification}, options: 𝓛[ty]2{<UNKNOWN>}}
type 𝓟[ty]937{IndexSpecification} = {access: (𝓛[ty]10051{String})->any}
Module: lib/InstanceInterface
type 𝓟[ty]938{InstanceImplementation} = {collection: 𝓛[ty]10051{String}, indexes: 𝓛[ty]8670{Array}, onReady: (any)->any, validators: 𝓛[ty]8670{Array}, mapReduceOptions: 𝓟[ty]764{MapReduceFunctions}, onRetrieved: (any)->any, cache: 𝓟[ty]500{CacheDirector}, schema: 𝓟[ty]501{Schema}, onSaving: (any,𝓟[ty]564{Changes})->any, onCreating: (any)->any, transforms: 𝓟[ty]772{Transforms}, CONSTRUCTOR: (𝓟[ty]947{Model},any,𝓛[ty]8666{Boolean},𝓛[ty]8666{Boolean})->any}
type 𝓟[ty]939{InstanceInternals} = {_original: any, _isPartial: 𝓛[ty]8666{Boolean}, _modified: any, _isNew: 𝓛[ty]8666{Boolean}, _model: 𝓟[ty]947{Model}}
Module: lib/Configuration
type 𝓟[ty]940{Configuration} = {database: 𝓛[ty]10051{String}, username: 𝓛[ty]10051{String}, host: 𝓛[ty]10051{String}, options: 𝓛[ty]2{<UNKNOWN>}, port: 𝓛[ty]8655{Number}, hosts: 𝓛[ty]8670{Array}, access: (𝓛[ty]10051{String})->any, password: 𝓛[ty]10051{String}}
Module: lib/Model
function 𝓟941{CONSTRUCTOR} (𝓟942{core}: 𝓟[ty]386{Core},𝓟943{instanceType}: [OOV]𝓟[ty]938{InstanceImplementation}): (𝓟[ty]947{Model})
{
const 𝓟[ty]947{Model};
const 𝓟[ty]947{Model};
𝓟[ty]947{Model}._hooks ⟵ {};
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟942{core},𝓛12643{undefined})))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟943{instanceType}),𝓛8743{String}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
if (𝓛12546{BarBarToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟943{instanceType}.collection),𝓛8743{String}),𝓛12569{ExclamationToken}(𝓟943{instanceType}.collection)))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟943{instanceType}.schema)),𝓛12559{EqualsEqualsEqualsToken}(𝓟943{instanceType}.schema._id,𝓛12643{undefined})))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
𝓟[ty]947{Model}._core ⟵ 𝓟942{core};
𝓟[ty]947{Model}.loadExternal(𝓟943{instanceType})
𝓟[ty]947{Model}.onNewModel()
𝓟[ty]947{Model}.loadInternal()
}
class 𝓟[ty]947{Model}{
𝓟949{_indexes}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
𝓟950{_handlers}: 𝓟[ty]1592{ModelHandlers};
𝓟951{_schema}: [OOV]𝓟[ty]501{Schema};
𝓟952{_Instance}: [OOV]𝓟[ty]502{ModelSpecificInstanceConstructor};
𝓟953{_cacheDirector}: [OOV]𝓟[ty]500{CacheDirector};
𝓟954{_cache}: 𝓟[ty]552{ModelCache};
𝓟955{_collection}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String});
𝓟956{_core}: 𝓟[ty]386{Core};
𝓟957{_hooks}: [OOV]𝓟[ty]379{Hooks};
𝓟958{_transforms}: [OOV]𝓟[ty]772{Transforms};
𝓟959{_helpers}: 𝓟[ty]1634{ModelHelpers};
𝓟960{_validators}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array});
function 𝓟1009{find} (𝓟1010{conditions}: [OOV]any,𝓟1011{fields}: [OOV]any): (𝓟1012: 𝓟[ty]247{Cursor})
{
𝓟1010{conditions} ⟵ 𝓛12546{BarBarToken}(𝓟1010{conditions},{});
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟1010{conditions})))
{
𝓟1010{conditions} ⟵ {_id: 𝓟1010{conditions}};
}
𝓟1010{conditions} ⟵ 𝓟[ty]947{Model}._helpers.convertToDB(𝓟1010{conditions});
let 𝓟1013{cursor} = 𝓟[ty]947{Model}.collection.find(𝓟1010{conditions});
if (𝓟1011{fields})
{
𝓟1013{cursor} ⟵ 𝓟1013{cursor}.project(𝓟1011{fields});
}
return 𝓟1012 = 𝓟240{CONSTRUCTOR}(𝓟[ty]947{Model},𝓟1010{conditions},𝓟1013{cursor})
}
function 𝓟1213{count} (𝓟1214{conds}: [OOV]any,𝓟1215{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟1216: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟1217{conditions}: [OOV]any = 𝓟1214{conds};
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1214{conds}),𝓛8743{String}))
{
𝓟1215{callback} ⟵ 𝓟1214{conds} as 𝓟[ty]1392{Callback};
𝓟1217{conditions} ⟵ {};
}
𝓟1217{conditions} ⟵ 𝓛12546{BarBarToken}(𝓟1217{conditions},{});
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟1217{conditions})))
{
𝓟1217{conditions} ⟵ {_id: 𝓟1217{conditions}};
}
function 𝓟1218{$Lambda153} (): (𝓟1219: [OOV]any)
{
𝓟1217{conditions} ⟵ 𝓟[ty]947{Model}._helpers.convertToDB(𝓟1217{conditions});
function 𝓟1220{$Lambda154} (𝓟1221{resolve},𝓟1222{reject}): (𝓟1223: [miss]𝓛[ty]10033{Void})
{
function 𝓟1224{$Lambda155} (𝓟1225{err},𝓟1226{results}): (𝓟1227: [OOV]any)
{
if (𝓟1225{err})
{
return 𝓟1227 = 𝓟1222{reject}(𝓟1225{err})
}
return 𝓟1227 = 𝓟1221{resolve}(𝓟1226{results})
}
𝓟[ty]947{Model}.collection.count(𝓟1217{conditions},𝓟1224{$Lambda155})
}
return 𝓟1219 = 𝓛23475{CONSTRUCTOR}(𝓟1220{$Lambda154})
}
return 𝓟1216 = 𝓛23509{resolve}().then(𝓟1218{$Lambda153}).nodeify(𝓟1215{callback})
}
function 𝓟988{cacheDirector} (): (𝓟989: [OOV]𝓟[ty]500{CacheDirector})
{
return 𝓟989 = 𝓟[ty]947{Model}._cacheDirector
}
function 𝓟966{onNewModel} (): (𝓟967: [miss]𝓛[ty]10033{Void})
{
function 𝓟968{$Lambda131} (𝓟969{plugin}): (𝓟970: [miss]𝓛[ty]10033{Void})
{
return 𝓟970 = 𝓛12592{AmpersandAmpersandToken}(𝓟969{plugin}.newModel,𝓟969{plugin}.newModel(𝓟[ty]947{Model}))
}
𝓟[ty]947{Model}._core.plugins.forEach(𝓟968{$Lambda131})
}
function 𝓟981{collection} (): (𝓟982: [OOV]𝓛[ty]2{<UNKNOWN>})
{
return 𝓟982 = 𝓟[ty]947{Model}.core.connection.collection(𝓟[ty]947{Model}._collection)
}
function 𝓟1127{insert} (𝓟1128{objs}: [OOV]any,𝓟1129{args}: 𝓛[ty]8670{Array}): (𝓟1130: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟1131{objects}: 𝓛[ty]8670{Array};
let 𝓟1132{options}: [OOV]𝓟[ty]213{CreateOptions} = {};
let 𝓟1133{callback}: [OOV]any = 𝓛12643{undefined};
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1129{args}.access(𝓛8745{Number})),𝓛8743{String}))
{
𝓟1133{callback} ⟵ 𝓟1129{args}.access(𝓛8745{Number});
}
else
{
𝓟1132{options} ⟵ 𝓟1129{args}.access(𝓛8745{Number});
𝓟1133{callback} ⟵ 𝓟1129{args}.access(𝓛8745{Number});
}
if (𝓛8757{Array}.isArray(𝓟1128{objs}))
{
𝓟1131{objects} ⟵ 𝓟1128{objs} as 𝓛[ty]8670{Array};
}
else
{
𝓟1131{objects} ⟵ 𝓛8757{Array}(𝓟1128{objs}) as 𝓛[ty]8670{Array};
}
𝓟1132{options} ⟵ 𝓛12546{BarBarToken}(𝓟1132{options},{});
𝓛1{<UNKNOWN>}(𝓟1132{options},{w: 𝓛8743{String},forceServerObjectId: 𝓛8744{Boolean}} as 𝓟[ty]213{CreateOptions})
function 𝓟1134{$Lambda138} (): (𝓟1135: [OOV]any)
{
let 𝓟1136{queryOptions}: [miss]𝓛[ty]8642{Object} = {w: 𝓟1132{options}.w,upsert: 𝓟1132{options}.upsert,new: 𝓛8744{Boolean}};
if (𝓟1132{options}.upsert)
{
let 𝓟1137{docs} = 𝓟[ty]947{Model}._handlers.creatingDocuments(𝓟1131{objects});
function 𝓟1138{$Lambda139} (𝓟1139{object}: 𝓛[ty]8642{Object}): (𝓟1140: [OOV]any)
{
function 𝓟1141{$Lambda140} (𝓟1142{resolve},𝓟1143{reject}): (𝓟1144: [miss]𝓛[ty]10033{Void})
{
function 𝓟1145{$Lambda141} (𝓟1146{err},𝓟1147{result}): (𝓟1148: [OOV]any)
{
if (𝓟1146{err})
{
return 𝓟1148 = 𝓟1143{reject}(𝓟1146{err})
}
return 𝓟1148 = 𝓟1142{resolve}(𝓟1147{result}.value)
}
𝓟[ty]947{Model}.collection.findOneAndUpdate({_id: 𝓛12546{BarBarToken}(𝓟1139{object}._id,{$exists: 𝓛8744{Boolean}})},𝓟1139{object},{upsert: 𝓟1132{options}.upsert,returnOriginal: 𝓛8744{Boolean}},𝓟1145{$Lambda141})
}
return 𝓟1140 = 𝓛23475{CONSTRUCTOR}(𝓟1141{$Lambda140})
}
return 𝓟1135 = 𝓟1137{docs}.map(𝓟1138{$Lambda139})
}
else
{
function 𝓟1149{$Lambda142} (𝓟1150{objects}): (𝓟1151: [OOV]any)
{
return 𝓟1151 = 𝓛1{<UNKNOWN>}(𝓟1150{objects},𝓛8745{Number})
}
function 𝓟1152{$Lambda143} (𝓟1153{objects}: 𝓛[ty]8670{Array}): (𝓟1154: [OOV]any)
{
function 𝓟1155{$Lambda144} (𝓟1156{resolve},𝓟1157{reject}): (𝓟1158: [miss]𝓛[ty]10033{Void})
{
function 𝓟1159{$Lambda145} (𝓟1160{err},𝓟1161{result}): (𝓟1162: [OOV]any)
{
if (𝓟1160{err})
{
return 𝓟1162 = 𝓟1157{reject}(𝓟1160{err})
}
return 𝓟1162 = 𝓟1156{resolve}(𝓟1161{result}.ops)
}
𝓟[ty]947{Model}.collection.insertMany(𝓟1153{objects},𝓟1136{queryOptions},𝓟1159{$Lambda145})
}
return 𝓟1154 = 𝓛23475{CONSTRUCTOR}(𝓟1155{$Lambda144})
}
function 𝓟1163{$Lambda146} (𝓟1164{results}): (𝓟1165: [OOV]any)
{
return 𝓟1165 = 𝓛1{<UNKNOWN>}(𝓟1164{results})
}
return 𝓟1135 = 𝓟[ty]947{Model}._handlers.creatingDocuments(𝓟1131{objects}).then(𝓟1149{$Lambda142}).map(𝓟1152{$Lambda143}).then(𝓟1163{$Lambda146})
}
}
function 𝓟1166{$Lambda147} (𝓟1167{inserted}: [OOV]any): (𝓟1168: [OOV]any)
{
function 𝓟1169{$Lambda148} (𝓟1170{document},𝓟1171{isNew},𝓟1172{isPartial}): (𝓟1173: [OOV]any)
{
return 𝓟1173 = 𝓟[ty]947{Model}._helpers.wrapDocument(𝓟1170{document},𝓟1171{isNew},𝓟1172{isPartial})
}
return 𝓟1168 = 𝓟[ty]947{Model}._handlers.documentReceived(𝓛12643{undefined},𝓟1167{inserted},𝓟1169{$Lambda148},{cache: 𝓟1132{options}.cache})
}
function 𝓟1174{$Lambda149} (𝓟1175{results}: 𝓛[ty]8670{Array}): (𝓟1176: [OOV]any)
{
if (𝓛8757{Array}.isArray(𝓟1128{objs}))
{
return 𝓟1176 = 𝓟1175{results}
}
return 𝓟1176 = 𝓟1175{results}.access(𝓛8745{Number})
}
return 𝓟1130 = 𝓛23509{resolve}().then(𝓟1134{$Lambda138}).map(𝓟1166{$Lambda147}).then(𝓟1174{$Lambda149}).nodeify(𝓟1133{callback})
}
function 𝓟998{indexes} (): (𝓟999)
{
return 𝓟999 = 𝓟[ty]947{Model}._indexes
}
function 𝓟1282{mapReduce} (𝓟1283{functions}: [OOV]any,𝓟1284{options}: [OOV]𝓟[ty]763{MapReduceOptions}): (𝓟1285)
{
type 𝓟[ty]764{MapReduceFunctions} = 𝓟[ty]764{MapReduceFunctions}
type 𝓟[ty]938{InstanceImplementation} = 𝓟[ty]938{InstanceImplementation}
if (𝓟1283{functions} as 𝓟[ty]764{MapReduceFunctions}.map)
{
function 𝓟1288{$Lambda163} (𝓟1289{resolve},𝓟1290{reject}): (𝓟1291: [OOV]any)
{
if (𝓛12592{AmpersandAmpersandToken}(𝓟1284{options}.out,𝓛12637{ExclamationEqualsToken}(𝓟1284{options}.out,𝓛8743{String})))
{
return 𝓟1291 = 𝓟1290{reject}(𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}))
}
let 𝓟1292{opts} = 𝓟1284{options} as 𝓛[ty]2{<UNKNOWN>};
𝓟1292{opts}.out ⟵ {inline: 𝓛8745{Number}};
function 𝓟1293{$Lambda164} (𝓟1294{err},𝓟1295{data}): (𝓟1296: [OOV]any)
{
if (𝓟1294{err})
{
return 𝓟1296 = 𝓟1290{reject}(𝓟1294{err})
}
return 𝓟1296 = 𝓟1289{resolve}(𝓟1295{data})
}
𝓟[ty]947{Model}.collection.mapReduce(𝓟1283{functions} as 𝓟[ty]764{MapReduceFunctions}.map,𝓟1283{functions} as 𝓟[ty]764{MapReduceFunctions}.reduce,𝓟1292{opts},𝓟1293{$Lambda164})
}
return 𝓟1285 = 𝓛23475{CONSTRUCTOR}(𝓟1288{$Lambda163})
}
else
{
let 𝓟1297{instanceType}: [OOV]𝓟[ty]938{InstanceImplementation} = 𝓟1283{functions} as 𝓟[ty]938{InstanceImplementation};
function 𝓟1298{$Lambda165} (𝓟1299{resolve},𝓟1300{reject}): (𝓟1301: [OOV]any)
{
if (𝓛12592{AmpersandAmpersandToken}(𝓟1284{options}.out,𝓛12599{EqualsEqualsToken}(𝓟1284{options}.out,𝓛8743{String})))
{
return 𝓟1301 = 𝓟1300{reject}(𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}))
}
if (𝓛12569{ExclamationToken}(𝓟1297{instanceType}.mapReduceOptions))
{
return 𝓟1301 = 𝓟1300{reject}(𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}))
}
let 𝓟1302{opts} = 𝓟1284{options} as 𝓛[ty]2{<UNKNOWN>};
let 𝓟1303{out}: 𝓛[ty]8642{Object} = {};
𝓟1303{out}.access(𝓟1284{options}.out as 𝓛[ty]10051{String}) ⟵ 𝓟1297{instanceType}.collection;
𝓟1302{opts}.out ⟵ 𝓟1303{out};
function 𝓟1304{$Lambda166} (𝓟1305{err},𝓟1306{data}): (𝓟1307: [OOV]any)
{
if (𝓟1305{err})
{
return 𝓟1307 = 𝓟1300{reject}(𝓟1305{err})
}
return 𝓟1307 = 𝓟1299{resolve}()
}
𝓟[ty]947{Model}.collection.mapReduce(𝓟1297{instanceType}.mapReduceOptions.map,𝓟1297{instanceType}.mapReduceOptions.reduce,𝓟1302{opts},𝓟1304{$Lambda166})
}
return 𝓟1285 = 𝓛23475{CONSTRUCTOR}(𝓟1298{$Lambda165})
}
}
function 𝓟996{validators} (): (𝓟997)
{
return 𝓟997 = 𝓟[ty]947{Model}._validators
}
function 𝓟1263{aggregate} (𝓟1264{pipeline}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1265: [OOV]𝓛[ty]2{<UNKNOWN>})
{
function 𝓟1266{$Lambda161} (𝓟1267{resolve},𝓟1268{reject}): (𝓟1269: [miss]𝓛[ty]10033{Void})
{
function 𝓟1270{$Lambda162} (𝓟1271{err},𝓟1272{results}): (𝓟1273: [OOV]any)
{
if (𝓟1271{err})
{
return 𝓟1273 = 𝓟1268{reject}(𝓟1271{err})
}
return 𝓟1273 = 𝓟1267{resolve}(𝓟1272{results})
}
𝓟[ty]947{Model}.collection.aggregate(𝓟1264{pipeline},𝓟1270{$Lambda162})
}
return 𝓟1265 = 𝓛23475{CONSTRUCTOR}(𝓟1266{$Lambda161})
}
function 𝓟1106{create} (𝓟1107{args}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1108: [OOV]𝓛[ty]2{<UNKNOWN>})
{
return 𝓟1108 = 𝓟[ty]947{Model}.insert.apply(𝓟[ty]947{Model},𝓟1107{args})
}
function 𝓟973{handlers} (): (𝓟974: (𝓟[ty]794{User} ≠ 𝓟[ty]1592{ModelHandlers}))
{
return 𝓟974 = 𝓟[ty]947{Model}._handlers
}
function 𝓟964{loadInternal} (): (𝓟965: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]947{Model}._cache ⟵ 𝓟547{CONSTRUCTOR}(𝓟[ty]947{Model});
𝓟[ty]947{Model}._helpers ⟵ 𝓟1626{CONSTRUCTOR}(𝓟[ty]947{Model});
𝓟[ty]947{Model}._handlers ⟵ 𝓟1587{CONSTRUCTOR}(𝓟[ty]947{Model});
}
function 𝓟990{cache} (): (𝓟991: (𝓟[ty]794{User} ≠ 𝓟[ty]552{ModelCache}))
{
return 𝓟991 = 𝓟[ty]947{Model}._cache
}
function 𝓟1059{findOne} (𝓟1060{args}: 𝓛[ty]8670{Array}): (𝓟1061: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟1062{conditions}: [OOV]any;
let 𝓟1063{options}: [OOV]any;
let 𝓟1064{callback}: [OOV]any;
{
let 𝓟1065{argI}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟1065{argI},𝓟1060{args}.length))
{
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1060{args}.access(𝓟1065{argI})),𝓛8743{String}))
{
𝓟1064{callback} ⟵ 𝓛12546{BarBarToken}(𝓟1064{callback},𝓟1060{args}.access(𝓟1065{argI}));
}
else
{
if (𝓛1{<UNKNOWN>}(𝓟1060{args}.access(𝓟1065{argI})))
{
if (𝓟1062{conditions})
{
𝓟1063{options} ⟵ 𝓟1060{args}.access(𝓟1065{argI});
}
else
{
𝓟1062{conditions} ⟵ 𝓟1060{args}.access(𝓟1065{argI});
}
}
else
{
𝓟1062{conditions} ⟵ {_id: 𝓟1060{args}.access(𝓟1065{argI})};
}
}
}
𝓛12556{POST_PlusPlusToken}(𝓟1065{argI})
}
}
𝓟1062{conditions} ⟵ 𝓛12546{BarBarToken}(𝓟1062{conditions},{});
𝓟1063{options} ⟵ 𝓛12546{BarBarToken}(𝓟1063{options},{});
𝓛1{<UNKNOWN>}(𝓟1063{options},{cache: 𝓛8744{Boolean}})
function 𝓟1066{$Lambda132} (): (𝓟1067: [OOV]any)
{
𝓟1062{conditions} ⟵ 𝓟[ty]947{Model}._helpers.convertToDB(𝓟1062{conditions});
return 𝓟1067 = 𝓟[ty]947{Model}._cache.get(𝓟1062{conditions})
}
function 𝓟1068{$Lambda133} (𝓟1069{cachedDocument}: [OOV]any): (𝓟1070: [OOV]any)
{
if (𝓟1069{cachedDocument})
{
return 𝓟1070 = 𝓟1069{cachedDocument}
}
function 𝓟1071{$Lambda134} (𝓟1072{resolve},𝓟1073{reject}): (𝓟1074: [OOV]any)
{
let 𝓟1075{cursor} = 𝓟[ty]947{Model}.collection.find(𝓟1062{conditions});
if (𝓟1063{options}.sort)
{
𝓟1075{cursor} ⟵ 𝓟1075{cursor}.sort(𝓟1063{options}.sort);
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1063{options}.skip),𝓛8743{String}))
{
𝓟1075{cursor} ⟵ 𝓟1075{cursor}.skip(𝓟1063{options}.skip);
}
𝓟1075{cursor} ⟵ 𝓟1075{cursor}.limit(𝓛8745{Number});
if (𝓟1063{options}.fields)
{
𝓟1075{cursor} ⟵ 𝓟1075{cursor}.project(𝓟1063{options}.fields);
}
function 𝓟1076{$Lambda135} (𝓟1077{err},𝓟1078{result}): (𝓟1079: [OOV]any)
{
if (𝓟1077{err})
{
return 𝓟1079 = 𝓟1073{reject}(𝓟1077{err})
}
return 𝓟1079 = 𝓟1072{resolve}(𝓟1078{result} as any)
}
return 𝓟1074 = 𝓟1075{cursor}.next(𝓟1076{$Lambda135})
}
return 𝓟1070 = 𝓛23475{CONSTRUCTOR}(𝓟1071{$Lambda134})
}
function 𝓟1080{$Lambda136} (𝓟1081{document}): (𝓟1082: [OOV]any)
{
if (𝓛12569{ExclamationToken}(𝓟1081{document}))
{
return 𝓟1082 = 𝓛23509{resolve}(𝓛12643{undefined})
}
function 𝓟1083{$Lambda137} (𝓟1084{document},𝓟1085{isNew},𝓟1086{isPartial}): (𝓟1087: [OOV]any)
{
return 𝓟1087 = 𝓟[ty]947{Model}._helpers.wrapDocument(𝓟1084{document},𝓟1085{isNew},𝓟1086{isPartial})
}
return 𝓟1082 = 𝓟[ty]947{Model}._handlers.documentReceived(𝓟1062{conditions},𝓟1081{document},𝓟1083{$Lambda137},𝓟1063{options})
}
return 𝓟1061 = 𝓛23509{resolve}().bind(𝓟[ty]947{Model}).then(𝓟1066{$Lambda132}).then(𝓟1068{$Lambda133}).then(𝓟1080{$Lambda136}).nodeify(𝓟1064{callback})
}
function 𝓟977{schema} (): (𝓟978: [OOV]𝓟[ty]501{Schema})
{
return 𝓟978 = 𝓟[ty]947{Model}._schema
}
function 𝓟1240{remove} (𝓟1241{conds}: [OOV]any,𝓟1242{options}: [OOV]𝓟[ty]212{RemoveOptions},𝓟1243{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟1244: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟1245{conditions}: [OOV]any = 𝓟1241{conds};
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1242{options}),𝓛8743{String}))
{
𝓟1243{callback} ⟵ 𝓟1242{options} as 𝓟[ty]1392{Callback};
𝓟1242{options} ⟵ {};
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1241{conds}),𝓛8743{String}))
{
𝓟1243{callback} ⟵ 𝓟1241{conds} as 𝓟[ty]1392{Callback};
𝓟1242{options} ⟵ {};
𝓟1245{conditions} ⟵ {};
}
𝓟1245{conditions} ⟵ 𝓛12546{BarBarToken}(𝓟1245{conditions},{});
𝓟1242{options} ⟵ 𝓛12546{BarBarToken}(𝓟1242{options},{});
𝓛1{<UNKNOWN>}(𝓟1242{options},{w: 𝓛8743{String}})
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟1245{conditions})))
{
𝓟1245{conditions} ⟵ {_id: 𝓟1245{conditions}};
}
function 𝓟1246{$Lambda156} (): (𝓟1247: [OOV]any)
{
𝓟1245{conditions} ⟵ 𝓟[ty]947{Model}._helpers.convertToDB(𝓟1245{conditions});
function 𝓟1248{$Lambda157} (𝓟1249{resolve},𝓟1250{reject}): (𝓟1251: [OOV]any)
{
if (𝓟1242{options}.single)
{
function 𝓟1252{$Lambda158} (𝓟1253{err},𝓟1254{response}): (𝓟1255: [OOV]any)
{
if (𝓟1253{err})
{
return 𝓟1255 = 𝓟1250{reject}(𝓟1253{err})
}
return 𝓟1255 = 𝓟1249{resolve}(𝓟1254{response}.result.n)
}
return 𝓟1251 = 𝓟[ty]947{Model}.collection.deleteOne(𝓟1245{conditions},𝓟1242{options},𝓟1252{$Lambda158})
}
function 𝓟1256{$Lambda159} (𝓟1257{err},𝓟1258{response}): (𝓟1259: [OOV]any)
{
if (𝓟1257{err})
{
return 𝓟1259 = 𝓟1250{reject}(𝓟1257{err})
}
return 𝓟1259 = 𝓟1249{resolve}(𝓟1258{response}.result.n)
}
𝓟[ty]947{Model}.collection.deleteMany(𝓟1245{conditions},𝓟1242{options},𝓟1256{$Lambda159})
}
return 𝓟1247 = 𝓛23475{CONSTRUCTOR}(𝓟1248{$Lambda157})
}
function 𝓟1260{$Lambda160} (𝓟1261{count}): (𝓟1262: [OOV]any)
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1261{count},𝓛12643{undefined}))
{
return 𝓟1262 = 𝓛23509{resolve}(𝓛8745{Number})
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1261{count},𝓛8745{Number}))
{
𝓟[ty]947{Model}._cache.clear(𝓟1245{conditions})
}
return 𝓟1262 = 𝓛23509{resolve}(𝓟1261{count})
}
return 𝓟1244 = 𝓛23509{resolve}().then(𝓟1246{$Lambda156}).then(𝓟1260{$Lambda160}).nodeify(𝓟1243{callback})
}
function 𝓟985{collectionName} (𝓟986{value}: 𝓛[ty]10051{String}): (𝓟987)
{
𝓟[ty]947{Model}._collection ⟵ 𝓟986{value};
}
function 𝓟1317{ensureIndex} (𝓟1318{specification}: [OOV]𝓟[ty]937{IndexSpecification},𝓟1319{options}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟1320{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟1321: [OOV]𝓛[ty]2{<UNKNOWN>})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1319{options}),𝓛8743{String}))
{
𝓟1320{callback} ⟵ 𝓟1319{options} as 𝓟[ty]1392{Callback};
𝓟1319{options} ⟵ {};
}
function 𝓟1322{$Lambda167} (𝓟1323{resolve},𝓟1324{reject}): (𝓟1325: [miss]𝓛[ty]10033{Void})
{
function 𝓟1326{$Lambda168} (𝓟1327{err}: (𝓟[ty]552{ModelCache} ≠ 𝓛[ty]10053{Error}),𝓟1328{name}: [OOV]any): (𝓟1329: [OOV]any)
{
if (𝓟1327{err})
{
return 𝓟1329 = 𝓟1324{reject}(𝓟1327{err})
}
return 𝓟1329 = 𝓟1323{resolve}(𝓟1328{name})
}
𝓟[ty]947{Model}.collection.createIndex(𝓟1318{specification},𝓛12546{BarBarToken}(𝓟1319{options},{}),𝓟1326{$Lambda168})
}
return 𝓟1321 = 𝓛23475{CONSTRUCTOR}(𝓟1322{$Lambda167}).nodeify(𝓟1320{callback})
}
function 𝓟1330{ensureIndexes} (𝓟1331{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟1332: [OOV]𝓛[ty]2{<UNKNOWN>})
{
function 𝓟1333{$Lambda169} (𝓟1334{index}: [OOV]any): (𝓟1335: [OOV]any)
{
return 𝓟1335 = 𝓟[ty]947{Model}.ensureIndex(𝓛12546{BarBarToken}(𝓟1334{index} as 𝓟[ty]936{Index}.spec,𝓟1334{index} as 𝓟[ty]937{IndexSpecification}),𝓛12546{BarBarToken}(𝓟1334{index} as 𝓟[ty]936{Index}.options,{}))
}
return 𝓟1332 = 𝓛23509{resolve}(𝓟[ty]947{Model}._indexes).map(𝓟1333{$Lambda169}).nodeify(𝓟1331{callback})
}
function 𝓟971{helpers} (): (𝓟972: (𝓟[ty]386{Core} ≠ 𝓟[ty]1634{ModelHelpers}))
{
return 𝓟972 = 𝓟[ty]947{Model}._helpers
}
function 𝓟1344{dropIndex} (𝓟1345{specification}: [OOV]any,𝓟1346{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟1347: [OOV]𝓛[ty]2{<UNKNOWN>})
{
let 𝓟1348{index}: [OOV]any;
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1345{specification}),𝓛8743{String}))
{
𝓟1348{index} ⟵ 𝓟1345{specification} as 𝓛[ty]10051{String};
}
else
{
function 𝓟1349{$Lambda170} (𝓟1350{direction}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟1351{key}: 𝓛[ty]10051{String}): (𝓟1352: [miss]𝓛[ty]10051{String})
{
return 𝓟1352 = 𝓛12607{$Template}(𝓟1351{key},𝓟1350{direction})
}
function 𝓟1353{$Lambda171} (𝓟1354{x},𝓟1355{y}): (𝓟1356: [miss]𝓛[ty]10051{String})
{
return 𝓟1356 = 𝓛12607{$Template}(𝓟1354{x},𝓟1355{y})
}
𝓟1348{index} ⟵ 𝓛12643{undefined}(𝓟1345{specification} as 𝓟[ty]937{IndexSpecification}).map(𝓟1349{$Lambda170}).reduce(𝓟1353{$Lambda171});
}
if (𝓛12569{ExclamationToken}(𝓟1348{index}))
{
return 𝓟1347 = 𝓛23512{reject}(𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}))
}
function 𝓟1357{$Lambda172} (𝓟1358{resolve},𝓟1359{reject}): (𝓟1360: [miss]𝓛[ty]10033{Void})
{
function 𝓟1361{$Lambda173} (𝓟1362{err}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10053{Error}),𝓟1363{result}: (𝓟[ty]794{User} ≠ 𝓛[ty]8642{Object})): (𝓟1364: [OOV]any)
{
if (𝓟1362{err})
{
return 𝓟1364 = 𝓟1359{reject}(𝓟1362{err})
}
return 𝓟1364 = 𝓟1358{resolve}(𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟1363{result}.ok)) as any)
}
𝓟[ty]947{Model}.collection.dropIndex(𝓟1348{index},𝓟1361{$Lambda173})
}
return 𝓟1347 = 𝓛23475{CONSTRUCTOR}(𝓟1357{$Lambda172}).nodeify(𝓟1346{callback})
}
function 𝓟994{transforms} (): (𝓟995)
{
return 𝓟995 = 𝓟[ty]947{Model}._transforms
}
function 𝓟975{hooks} (): (𝓟976: [OOV]𝓟[ty]379{Hooks})
{
return 𝓟976 = 𝓟[ty]947{Model}._hooks
}
function 𝓟1035{get} (𝓟1036{args}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1037: [OOV]𝓛[ty]2{<UNKNOWN>})
{
return 𝓟1037 = 𝓟[ty]947{Model}.findOne.apply(𝓟[ty]947{Model},𝓟1036{args})
}
function 𝓟1188{update} (𝓟1189{conditions}: [OOV]any,𝓟1190{changes}: [OOV]𝓟[ty]564{Changes},𝓟1191{options}: [OOV]𝓟[ty]214{UpdateOptions},𝓟1192{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟1193: [OOV]𝓛[ty]2{<UNKNOWN>})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1191{options}),𝓛8743{String}))
{
𝓟1192{callback} ⟵ 𝓟1191{options} as 𝓟[ty]1392{Callback};
𝓟1191{options} ⟵ {};
}
const 𝓟1194{opts}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛12546{BarBarToken}(𝓟1191{options},{});
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟1189{conditions})))
{
𝓟1189{conditions} ⟵ {_id: 𝓟1189{conditions}};
}
𝓛1{<UNKNOWN>}(𝓟1194{opts},{w: 𝓛8743{String},multi: 𝓛8744{Boolean}})
function 𝓟1195{$Lambda150} (): (𝓟1196: [OOV]any)
{
𝓟1189{conditions} ⟵ 𝓟[ty]947{Model}._helpers.convertToDB(𝓟1189{conditions});
function 𝓟1197{$Lambda151} (𝓟1198{resolve},𝓟1199{reject}): (𝓟1200: [OOV]any)
{
function 𝓟1201{$Lambda152} (𝓟1202{err}: (𝓟[ty]552{ModelCache} ≠ 𝓛[ty]10053{Error}),𝓟1203{response}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1204: [OOV]any)
{
if (𝓟1202{err})
{
return 𝓟1204 = 𝓟1199{reject}(𝓟1202{err})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓟1203{response}.result,𝓛12612{ExclamationEqualsEqualsToken}(𝓟1203{response}.result.nModified,𝓛12643{undefined})))
{
return 𝓟1204 = 𝓟1198{resolve}(𝓟1203{response}.result.nModified)
}
return 𝓟1204 = 𝓟1198{resolve}(𝓟1203{response}.result.n)
}
const 𝓟1205{callback}: [miss]𝓛[ty]8696{Function} = 𝓟1201{$Lambda152};
if (𝓟1194{opts}.multi)
{
return 𝓟1200 = 𝓟[ty]947{Model}.collection.updateMany(𝓟1189{conditions},𝓟1190{changes},𝓟1194{opts},𝓟1205{callback})
}
return 𝓟1200 = 𝓟[ty]947{Model}.collection.updateOne(𝓟1189{conditions},𝓟1190{changes},𝓟1194{opts},𝓟1205{callback})
}
return 𝓟1196 = 𝓛23475{CONSTRUCTOR}(𝓟1197{$Lambda151})
}
return 𝓟1193 = 𝓛23509{resolve}().then(𝓟1195{$Lambda150}).nodeify(𝓟1192{callback})
}
function 𝓟1365{dropIndexes} (𝓟1366{callback}: [OOV]𝓟[ty]1392{Callback}): (𝓟1367: [OOV]𝓛[ty]2{<UNKNOWN>})
{
function 𝓟1368{$Lambda174} (𝓟1369{resolve},𝓟1370{reject}): (𝓟1371: [miss]𝓛[ty]10033{Void})
{
function 𝓟1372{$Lambda175} (𝓟1373{err},𝓟1374{count}): (𝓟1375: [OOV]any)
{
if (𝓟1373{err})
{
return 𝓟1375 = 𝓟1370{reject}(𝓟1373{err})
}
return 𝓟1375 = 𝓟1369{resolve}(𝓟1374{count})
}
𝓟[ty]947{Model}.collection.dropIndexes(𝓟1372{$Lambda175})
}
return 𝓟1367 = 𝓛23475{CONSTRUCTOR}(𝓟1368{$Lambda174}).nodeify(𝓟1366{callback})
}
function 𝓟979{core} (): (𝓟980: (𝓟[ty]794{User} ≠ 𝓟[ty]386{Core}))
{
return 𝓟980 = 𝓟[ty]947{Model}._core
}
function 𝓟992{Instance} (): (𝓟993: [OOV]𝓟[ty]502{ModelSpecificInstanceConstructor})
{
return 𝓟993 = 𝓟[ty]947{Model}._Instance
}
function 𝓟961{loadExternal} (𝓟962{instanceType}: [OOV]𝓟[ty]938{InstanceImplementation}): (𝓟963: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]947{Model}._collection ⟵ 𝓟962{instanceType}.collection;
𝓟[ty]947{Model}._schema ⟵ 𝓟962{instanceType}.schema;
𝓟[ty]947{Model}._hooks ⟵ 𝓟962{instanceType};
𝓟[ty]947{Model}._cacheDirector ⟵ 𝓛12546{BarBarToken}(𝓟962{instanceType}.cache,𝓟526{CONSTRUCTOR}());
𝓟[ty]947{Model}._transforms ⟵ 𝓛12546{BarBarToken}(𝓟962{instanceType}.transforms,{});
𝓟[ty]947{Model}._validators ⟵ 𝓛12546{BarBarToken}(𝓟962{instanceType}.validators,𝓛8757{Array}());
𝓟[ty]947{Model}._indexes ⟵ 𝓛12546{BarBarToken}(𝓟962{instanceType}.indexes,𝓛8757{Array}());
if (𝓛12569{ExclamationToken}(𝓟[ty]947{Model}._schema._id))
{
𝓟[ty]947{Model}._schema._id ⟵ 𝓛1{<UNKNOWN>};
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]947{Model}._schema._id,𝓛1{<UNKNOWN>}),𝓛12569{ExclamationToken}(𝓟[ty]947{Model}._transforms._id)))
{
𝓟[ty]947{Model}._transforms._id ⟵ 𝓟785{DefaultTransforms}.ObjectID;
}
if (𝓛1{<UNKNOWN>}(𝓟962{instanceType} as 𝓛[ty]8696{Function}.prototype,𝓟992{Instance}))
{
𝓟[ty]947{Model}._Instance ⟵ 𝓟216{ModelSpecificInstance}(𝓟[ty]947{Model},𝓟962{instanceType});
}
else
{
𝓟[ty]947{Model}._Instance ⟵ 𝓟962{instanceType}.bind(𝓛12643{undefined},𝓟[ty]947{Model});
}
}
}
Module: lib/utils/UrlBuilder
function 𝓟1376{BuildUrl} (𝓟1377{config}: [OOV]𝓟[ty]940{Configuration}): (𝓟1378: 𝓛[ty]10051{String})
{
let 𝓟1379{url}: 𝓛[ty]10051{String} = 𝓛8743{String};
if (𝓟1377{config}.username)
{
𝓛12564{FirstCompoundAssignment}(𝓟1379{url},𝓟1377{config}.username)
if (𝓟1377{config}.password)
{
𝓛12564{FirstCompoundAssignment}(𝓟1379{url},𝓛12641{PlusToken}(𝓛8743{String},𝓟1377{config}.password))
}
𝓛12564{FirstCompoundAssignment}(𝓟1379{url},𝓛8743{String})
}
𝓛12564{FirstCompoundAssignment}(𝓟1379{url},𝓟1380{buildHostList}(𝓟1377{config}))
if (𝓟1377{config}.database)
{
𝓛12564{FirstCompoundAssignment}(𝓟1379{url},𝓛12641{PlusToken}(𝓛8743{String},𝓟1377{config}.database))
}
return 𝓟1378 = 𝓟1379{url}
}
function 𝓟1380{buildHostList} (𝓟1381{config}: [OOV]𝓟[ty]940{Configuration}): (𝓟1382: 𝓛[ty]10051{String})
{
let 𝓟1383{hosts}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
if (𝓟1381{config}.host)
{
if (𝓟1381{config}.port)
{
𝓟1383{hosts}.push(𝓛12607{$Template}(𝓟1381{config}.host,𝓟1381{config}.port))
}
else
{
𝓟1383{hosts}.push(𝓟1381{config}.host)
}
}
if (𝓟1381{config}.hosts)
{
function 𝓟1384{$Lambda204} (𝓟1385{host}): (𝓟1386: [miss]𝓛[ty]10033{Void})
{
if (𝓟1385{host}.port)
{
𝓟1383{hosts}.push(𝓛12607{$Template}(𝓟1385{host}.address,𝓟1385{host}.port))
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓟1381{config},𝓟1381{config}.port))
{
𝓟1383{hosts}.push(𝓛12607{$Template}(𝓟1385{host}.address,𝓟1381{config}.port))
}
else
{
𝓟1383{hosts}.push(𝓟1385{host}.address)
}
}
}
𝓟1381{config}.hosts.forEach(𝓟1384{$Lambda204})
}
if (𝓟1383{hosts}.length)
{
return 𝓟1382 = 𝓟1685{uniq}(𝓟1383{hosts}).join(𝓛8743{String})
}
else
{
return 𝓟1382 = 𝓛8743{String}
}
}
Module: lib/Conditions
type 𝓟[ty]1387{Conditions} = {access: (𝓛[ty]10051{String})->any}
Module: iridium
Module: lib/General
type 𝓟[ty]1388{PropertyGetter} = {call: ()->any}
type 𝓟[ty]1389{Property} = {get: 𝓟[ty]1388{PropertyGetter}, set: 𝓟[ty]1390{PropertySetter}}
type 𝓟[ty]1390{PropertySetter} = {call: (any)->𝓛[ty]10033{Void}}
type 𝓟[ty]1391{Predicate} = {call: (any,any,𝓛[ty]10051{String})->𝓛[ty]8666{Boolean}}
type 𝓟[ty]1392{Callback} = {call: (𝓛[ty]10053{Error},any)->𝓛[ty]10033{Void}}
Module: lib/middleware/Express
type 𝓟[ty]1393{ExpressMiddleware} = {call: (𝓛[ty]2{<UNKNOWN>},𝓛[ty]9043{ServerResponse},((𝓛[ty]10053{Error},𝓛[ty]10051{String})->𝓛[ty]10033{Void}))->𝓛[ty]10033{Void}}
function 𝓟1394{ExpressMiddlewareFactory} (𝓟1395{core}: 𝓟[ty]386{Core}): (𝓟1396: [OOV]𝓟[ty]1393{ExpressMiddleware})
{
function 𝓟1397{$Lambda197} (𝓟1398{req}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟1399{res}: (𝓟[ty]552{ModelCache} ≠ 𝓛[ty]9043{ServerResponse}),𝓟1400{next}: 𝓛[ty]8696{Function}): (𝓟1401: [miss]𝓛[ty]10033{Void})
{
function 𝓟1402{$Lambda198} (): (𝓟1403: [miss]𝓛[ty]10033{Void})
{
function 𝓟1404{$Lambda199} (): (𝓟1405: [miss]𝓟[ty]386{Core})
{
return 𝓟1405 = 𝓟1395{core}
}
𝓛8741{Object}.defineProperty(𝓟1398{req},𝓛8743{String},{get: 𝓟1404{$Lambda199}})
𝓟1400{next}()
}
𝓟1395{core}.connect().then(𝓟1402{$Lambda198}).catch(𝓟1400{next})
}
return 𝓟1396 = 𝓟1397{$Lambda197}
}
Module: benchmarks/mongodb
type 𝓟[ty]1406{UserDocument} = {_id: 𝓛[ty]10051{String}}
let 𝓟1407{intensity}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
let 𝓟1408{samples}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
const 𝓟1409{collection}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟1410{schema}: [miss]𝓛[ty]8642{Object} = {_id: 𝓛8743{String}};
function 𝓟1411{CONSTRUCTOR} (): (𝓟[ty]1415{User})
{
const 𝓟[ty]1415{User};
const 𝓟[ty]1415{User};
}
class 𝓟[ty]1415{User}{
𝓟1417{_id}: 𝓛[ty]10051{String};
}
function 𝓟1418{CONSTRUCTOR} (): (𝓟[ty]1422{WrappedUser})
{
const 𝓟[ty]1422{WrappedUser};
const 𝓟[ty]1422{WrappedUser};
}
class 𝓟[ty]1422{WrappedUser} extends 𝓛[ty]2{<UNKNOWN>}{
𝓟1424{_id}: 𝓛[ty]10051{String};
}
function 𝓟1425{CONSTRUCTOR} (): (𝓟[ty]1429{IridiumDB})
{
const 𝓟[ty]1429{IridiumDB};
const 𝓟[ty]1429{IridiumDB};
𝓟[ty]1429{IridiumDB}.UserWrapped ⟵ 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟[ty]1429{IridiumDB},𝓛12643{undefined});
𝓟[ty]1429{IridiumDB}.User ⟵ 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟[ty]1429{IridiumDB},𝓛12643{undefined});
𝓟[ty]1429{IridiumDB}({database: 𝓛8743{String}})
}
class 𝓟[ty]1429{IridiumDB} extends 𝓛[ty]2{<UNKNOWN>}{
𝓟1431{User}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟1432{UserWrapped}: [OOV]𝓛[ty]2{<UNKNOWN>};
}
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟1407{intensity},𝓟1408{samples})
let 𝓟1433{results}: 𝓛[ty]8642{Object} = {};
function 𝓟1434{benchmark} (𝓟1435{name}: 𝓛[ty]10051{String},𝓟1436{prepare}: 𝓛[ty]8696{Function},𝓟1437{run}: 𝓛[ty]8696{Function},𝓟1438{compareTo}: 𝓛[ty]10051{String}): (𝓟1439: [OOV]any)
{
function 𝓟1440{$Lambda0} (): (𝓟1441: [OOV]any)
{
let 𝓟1442{objects}: 𝓛[ty]8670{Array} = 𝓛8757{Array}.CONSTRUCTOR(𝓟1407{intensity});
{
let 𝓟1443{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟1443{i},𝓟1442{objects}.length))
{
𝓟1442{objects}.access(𝓟1443{i}) ⟵ {_id: 𝓛1570{pseudoRandomBytes}(𝓛8745{Number}).toString(𝓛8743{String})};
𝓛12556{POST_PlusPlusToken}(𝓟1443{i})
}
}
function 𝓟1444{$Lambda1} (): (𝓟1445: [OOV]any)
{
return 𝓟1445 = 𝓟1436{prepare}(𝓟1442{objects})
}
function 𝓟1446{$Lambda2} (): (𝓟1447: [OOV]any)
{
let 𝓟1448{start}: [miss]𝓛[ty]8635{Date} = 𝓛8747{Date}.CONSTRUCTOR();
function 𝓟1449{$Lambda3} (): (𝓟1450: [OOV]any)
{
return 𝓟1450 = 𝓟1437{run}(𝓟1442{objects})
}
function 𝓟1451{$Lambda4} (): (𝓟1452: [miss]𝓛[ty]8655{Number})
{
let 𝓟1453{time}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓛8747{Date}.CONSTRUCTOR().valueOf(),𝓟1448{start}.valueOf());
return 𝓟1452 = 𝓟1453{time}
}
return 𝓟1447 = 𝓛23509{resolve}().then(𝓟1449{$Lambda3}).then(𝓟1451{$Lambda4})
}
return 𝓟1441 = 𝓛23509{resolve}().then(𝓟1444{$Lambda1}).then(𝓟1446{$Lambda2})
}
function 𝓟1454{$Lambda5} (𝓟1455{times}): (𝓟1456: [miss]𝓛[ty]8655{Number})
{
function 𝓟1457{$Lambda6} (𝓟1458{x},𝓟1459{y}): (𝓟1460: [OOV]any)
{
return 𝓟1460 = 𝓛12641{PlusToken}(𝓟1458{x},𝓟1459{y})
}
𝓟1433{results}.access(𝓟1435{name}) ⟵ 𝓛12573{SlashToken}(𝓛1{<UNKNOWN>}(𝓟1455{times} as any as 𝓛[ty]8670{Array},𝓟1457{$Lambda6},𝓛8745{Number}),𝓟1455{times}.length);
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟1435{name},𝓟1433{results}.access(𝓟1435{name}))
if (𝓟1438{compareTo})
{
if (𝓛1{<UNKNOWN>}(𝓛12573{SlashToken}(𝓛8746{Math}.abs(𝓛12616{MinusToken}(𝓟1433{results}.access(𝓟1435{name}),𝓟1433{results}.access(𝓟1438{compareTo}))),𝓟1433{results}.access(𝓟1438{compareTo})),𝓛8745{Number}))
{
}
else
{
if (𝓛12595{GreaterThanToken}(𝓟1433{results}.access(𝓟1435{name}),𝓟1433{results}.access(𝓟1438{compareTo})))
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓛12573{SlashToken}(𝓟1433{results}.access(𝓟1435{name}),𝓟1433{results}.access(𝓟1438{compareTo})).toPrecision(𝓛8745{Number}),𝓟1438{compareTo})
}
else
{
if (𝓛1{<UNKNOWN>}(𝓟1433{results}.access(𝓟1435{name}),𝓟1433{results}.access(𝓟1438{compareTo})))
{
𝓛1{<UNKNOWN>}(𝓛8743{String},𝓛12573{SlashToken}(𝓟1433{results}.access(𝓟1435{name}),𝓟1433{results}.access(𝓟1438{compareTo})).toPrecision(𝓛8745{Number}),𝓟1438{compareTo})
}
}
}
}
return 𝓟1456 = 𝓟1433{results}.access(𝓟1435{name})
}
return 𝓟1439 = 𝓛23509{resolve}(𝓛8757{Array}.CONSTRUCTOR(𝓟1408{samples})).map(𝓟1440{$Lambda0},{concurrency: 𝓛8745{Number}}).then(𝓟1454{$Lambda5})
}
let 𝓟1461{iDB}: [miss]𝓟[ty]1429{IridiumDB} = 𝓟1425{CONSTRUCTOR}();
function 𝓟1462{$Lambda7} (): (𝓟1463: [OOV]any)
{
return 𝓟1463 = 𝓟1461{iDB}.User.remove()
}
function 𝓟1464{$Lambda8} (): (𝓟1465: [OOV]any)
{
return 𝓟1465 = 𝓟1461{iDB}.UserWrapped.remove()
}
function 𝓟1466{$Lambda9} (): (𝓟1467: [OOV]any)
{
function 𝓟1468{$Lambda10} (𝓟1469{resolve},𝓟1470{reject}): (𝓟1471: [miss]𝓛[ty]10033{Void})
{
function 𝓟1472{$Lambda11} (𝓟1473{err}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10053{Error})): (𝓟1474: [OOV]any)
{
if (𝓟1473{err})
{
return 𝓟1474 = 𝓟1470{reject}(𝓟1473{err})
}
return 𝓟1474 = 𝓟1469{resolve}(𝓛12643{undefined})
}
𝓟1461{iDB}.connection.collection(𝓛8743{String}).deleteMany(𝓟1472{$Lambda11})
}
return 𝓟1467 = 𝓛23475{CONSTRUCTOR}(𝓟1468{$Lambda10})
}
function 𝓟1475{$Lambda12} (): (𝓟1476: [OOV]any)
{
function 𝓟1477{$Lambda13} (): (𝓟1478: [OOV]any)
{
function 𝓟1479{$Lambda14} (𝓟1480{resolve},𝓟1481{reject}): (𝓟1482: [miss]𝓛[ty]10033{Void})
{
function 𝓟1483{$Lambda15} (𝓟1484{err}): (𝓟1485: [OOV]any)
{
if (𝓟1484{err})
{
return 𝓟1485 = 𝓟1481{reject}(𝓟1484{err})
}
return 𝓟1485 = 𝓟1480{resolve}({})
}
𝓟1461{iDB}.connection.collection(𝓛8743{String}).deleteMany({},𝓟1483{$Lambda15})
}
return 𝓟1478 = 𝓛23475{CONSTRUCTOR}(𝓟1479{$Lambda14})
}
function 𝓟1486{$Lambda16} (𝓟1487{objects}): (𝓟1488: [OOV]any)
{
function 𝓟1489{$Lambda17} (𝓟1490{resolve},𝓟1491{reject}): (𝓟1492: [miss]𝓛[ty]10033{Void})
{
function 𝓟1493{$Lambda18} (𝓟1494{err},𝓟1495{objects}): (𝓟1496: [OOV]any)
{
if (𝓟1494{err})
{
return 𝓟1496 = 𝓟1491{reject}(𝓟1494{err})
}
return 𝓟1496 = 𝓟1490{resolve}(𝓟1495{objects})
}
𝓟1461{iDB}.connection.collection(𝓛8743{String}).insertMany(𝓟1487{objects},𝓟1493{$Lambda18})
}
return 𝓟1488 = 𝓛23475{CONSTRUCTOR}(𝓟1489{$Lambda17})
}
return 𝓟1476 = 𝓟1434{benchmark}(𝓛8743{String},𝓟1477{$Lambda13},𝓟1486{$Lambda16})
}
function 𝓟1497{$Lambda19} (): (𝓟1498: [OOV]any)
{
function 𝓟1499{$Lambda20} (): (𝓟1500: [OOV]any)
{
return 𝓟1500 = 𝓟1461{iDB}.User.remove()
}
function 𝓟1501{$Lambda21} (𝓟1502{objects}): (𝓟1503: [OOV]any)
{
return 𝓟1503 = 𝓟1461{iDB}.User.insert(𝓟1502{objects})
}
return 𝓟1498 = 𝓟1434{benchmark}(𝓛8743{String},𝓟1499{$Lambda20},𝓟1501{$Lambda21},𝓛8743{String})
}
function 𝓟1504{$Lambda22} (): (𝓟1505: [OOV]any)
{
function 𝓟1506{$Lambda23} (): (𝓟1507: [OOV]any)
{
return 𝓟1507 = 𝓟1461{iDB}.UserWrapped.remove()
}
function 𝓟1508{$Lambda24} (𝓟1509{objects}): (𝓟1510: [OOV]any)
{
return 𝓟1510 = 𝓟1461{iDB}.UserWrapped.insert(𝓟1509{objects})
}
return 𝓟1505 = 𝓟1434{benchmark}(𝓛8743{String},𝓟1506{$Lambda23},𝓟1508{$Lambda24},𝓛8743{String})
}
function 𝓟1511{$Lambda25} (): (𝓟1512: [OOV]any)
{
function 𝓟1513{$Lambda26} (): (𝓟1514: [OOV]any)
{
return 𝓟1514 = 𝓛12643{undefined}
}
function 𝓟1515{$Lambda27} (): (𝓟1516: [OOV]any)
{
function 𝓟1517{$Lambda28} (𝓟1518{resolve},𝓟1519{reject}): (𝓟1520: [miss]𝓛[ty]10033{Void})
{
function 𝓟1521{$Lambda29} (𝓟1522{err}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10053{Error}),𝓟1523{objects}: [OOV]any): (𝓟1524: [OOV]any)
{
if (𝓟1522{err})
{
return 𝓟1524 = 𝓟1519{reject}(𝓟1522{err})
}
return 𝓟1524 = 𝓟1518{resolve}(𝓟1523{objects})
}
𝓟1461{iDB}.connection.collection(𝓛8743{String}).find({}).toArray(𝓟1521{$Lambda29})
}
return 𝓟1516 = 𝓛23475{CONSTRUCTOR}(𝓟1517{$Lambda28})
}
return 𝓟1512 = 𝓟1434{benchmark}(𝓛8743{String},𝓟1513{$Lambda26},𝓟1515{$Lambda27})
}
function 𝓟1525{$Lambda30} (): (𝓟1526: [OOV]any)
{
function 𝓟1527{$Lambda31} (): (𝓟1528: [OOV]any)
{
return 𝓟1528 = 𝓛12643{undefined}
}
function 𝓟1529{$Lambda32} (): (𝓟1530: [OOV]any)
{
return 𝓟1530 = 𝓟1461{iDB}.User.find().toArray()
}
return 𝓟1526 = 𝓟1434{benchmark}(𝓛8743{String},𝓟1527{$Lambda31},𝓟1529{$Lambda32},𝓛8743{String})
}
function 𝓟1531{$Lambda33} (): (𝓟1532: [OOV]any)
{
function 𝓟1533{$Lambda34} (): (𝓟1534: [OOV]any)
{
return 𝓟1534 = 𝓛12643{undefined}
}
function 𝓟1535{$Lambda35} (): (𝓟1536: [OOV]any)
{
return 𝓟1536 = 𝓟1461{iDB}.UserWrapped.find().toArray()
}
return 𝓟1532 = 𝓟1434{benchmark}(𝓛8743{String},𝓟1533{$Lambda34},𝓟1535{$Lambda35},𝓛8743{String})
}
function 𝓟1537{$Lambda36} (): (𝓟1538: [OOV]any)
{
function 𝓟1539{$Lambda37} (𝓟1540{resolve},𝓟1541{reject}): (𝓟1542: [miss]𝓛[ty]10033{Void})
{
function 𝓟1543{$Lambda38} (𝓟1544{err}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10053{Error}),𝓟1545{objects}: [OOV]any): (𝓟1546: [OOV]any)
{
if (𝓟1544{err})
{
return 𝓟1546 = 𝓟1541{reject}(𝓟1544{err})
}
return 𝓟1546 = 𝓟1540{resolve}(𝓟1545{objects})
}
𝓟1461{iDB}.connection.collection(𝓛8743{String}).deleteMany(𝓟1543{$Lambda38})
}
return 𝓟1538 = 𝓛23475{CONSTRUCTOR}(𝓟1539{$Lambda37})
}
function 𝓟1547{$Lambda39} (): (𝓟1548: [OOV]any)
{
function 𝓟1549{$Lambda40} (𝓟1550{objects}): (𝓟1551: [OOV]any)
{
function 𝓟1552{$Lambda41} (𝓟1553{resolve},𝓟1554{reject}): (𝓟1555: [miss]𝓛[ty]10033{Void})
{
function 𝓟1556{$Lambda42} (𝓟1557{err},𝓟1558{objects}): (𝓟1559: [OOV]any)
{
if (𝓟1557{err})
{
return 𝓟1559 = 𝓟1554{reject}(𝓟1557{err})
}
return 𝓟1559 = 𝓟1553{resolve}(𝓟1558{objects})
}
𝓟1461{iDB}.connection.collection(𝓛8743{String}).deleteMany(𝓟1550{objects},𝓟1556{$Lambda42})
}
return 𝓟1551 = 𝓛23475{CONSTRUCTOR}(𝓟1552{$Lambda41})
}
function 𝓟1560{$Lambda43} (): (𝓟1561: [OOV]any)
{
function 𝓟1562{$Lambda44} (𝓟1563{resolve},𝓟1564{reject}): (𝓟1565: [miss]𝓛[ty]10033{Void})
{
function 𝓟1566{$Lambda45} (𝓟1567{err}: (𝓟[ty]247{Cursor} ≠ 𝓛[ty]10053{Error}),𝓟1568{objects}: [OOV]any): (𝓟1569: [OOV]any)
{
if (𝓟1567{err})
{
return 𝓟1569 = 𝓟1564{reject}(𝓟1567{err})
}
return 𝓟1569 = 𝓟1563{resolve}(𝓟1568{objects})
}
𝓟1461{iDB}.connection.collection(𝓛8743{String}).deleteMany(𝓟1566{$Lambda45})
}
return 𝓟1561 = 𝓛23475{CONSTRUCTOR}(𝓟1562{$Lambda44})
}
return 𝓟1548 = 𝓟1434{benchmark}(𝓛8743{String},𝓟1549{$Lambda40},𝓟1560{$Lambda43})
}
function 𝓟1570{$Lambda46} (): (𝓟1571: [OOV]any)
{
return 𝓟1571 = 𝓟1461{iDB}.User.remove()
}
function 𝓟1572{$Lambda47} (): (𝓟1573: [OOV]any)
{
function 𝓟1574{$Lambda48} (𝓟1575{objects}): (𝓟1576: [OOV]any)
{
return 𝓟1576 = 𝓟1461{iDB}.User.insert(𝓟1575{objects})
}
function 𝓟1577{$Lambda49} (): (𝓟1578: [OOV]any)
{
return 𝓟1578 = 𝓟1461{iDB}.User.remove()
}
return 𝓟1573 = 𝓟1434{benchmark}(𝓛8743{String},𝓟1574{$Lambda48},𝓟1577{$Lambda49},𝓛8743{String})
}
function 𝓟1579{$Lambda50} (): (𝓟1580: [OOV]any)
{
return 𝓟1580 = 𝓟1461{iDB}.UserWrapped.remove()
}
function 𝓟1581{$Lambda51} (𝓟1582{err}): (𝓟1583: [miss]𝓛[ty]10033{Void})
{
return 𝓟1583 = 𝓛1{<UNKNOWN>}(𝓟1582{err})
}
function 𝓟1584{$Lambda52} (): (𝓟1585: [OOV]any)
{
return 𝓟1585 = 𝓟1461{iDB}.close()
}
𝓟1461{iDB}.connect().then(𝓟1462{$Lambda7}).then(𝓟1464{$Lambda8}).then(𝓟1466{$Lambda9}).then(𝓟1475{$Lambda12}).then(𝓟1497{$Lambda19}).then(𝓟1504{$Lambda22}).then(𝓟1511{$Lambda25}).then(𝓟1525{$Lambda30}).then(𝓟1531{$Lambda33}).then(𝓟1537{$Lambda36}).then(𝓟1547{$Lambda39}).then(𝓟1570{$Lambda46}).then(𝓟1572{$Lambda47}).then(𝓟1579{$Lambda50}).catch(𝓟1581{$Lambda51}).finally(𝓟1584{$Lambda52})
Module: lib/Plugins
type 𝓟[ty]1586{Plugin} = {newModel: (𝓟[ty]947{Model})->𝓛[ty]10033{Void}, newInstance: (any,𝓟[ty]947{Model})->𝓛[ty]10033{Void}, validate: any}
Module: lib/ModelHandlers
function 𝓟1587{CONSTRUCTOR} (𝓟1588{model}: 𝓟[ty]947{Model}): (𝓟[ty]1592{ModelHandlers})
{
const 𝓟[ty]1592{ModelHandlers};
const 𝓟[ty]1592{ModelHandlers};
𝓟[ty]1592{ModelHandlers}.model ⟵ 𝓟1588{model};
}
class 𝓟[ty]1592{ModelHandlers}{
𝓟1594{model}: 𝓟[ty]947{Model};
function 𝓟1595{documentReceived} (𝓟1596{conditions}: [OOV]any,𝓟1597{result}: [OOV]any,𝓟1598{wrapper}: 𝓛[ty]8696{Function},𝓟1599{options}: [OOV]𝓟[ty]211{QueryOptions}): (𝓟1600: [OOV]𝓛[ty]2{<UNKNOWN>})
{
𝓛1{<UNKNOWN>}(𝓟1599{options},{cache: 𝓛8744{Boolean},partial: 𝓛8744{Boolean}})
let 𝓟1601{wrapped}: [OOV]any;
function 𝓟1602{$Lambda176} (𝓟1603{target}: [OOV]any): (𝓟1604: [OOV]any)
{
function 𝓟1605{$Lambda177} (): (𝓟1606: [OOV]any)
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓟[ty]1592{ModelHandlers}.model.core.cache,𝓟1599{options}.cache),𝓛12569{ExclamationToken}(𝓟1599{options}.fields)))
{
𝓟[ty]1592{ModelHandlers}.model.cache.set(𝓟1603{target})
}
let 𝓟1607{wrapped}: [OOV]any = 𝓟1598{wrapper}(𝓟1603{target},𝓛8744{Boolean},𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟1599{options}.fields)));
if (𝓟[ty]1592{ModelHandlers}.model.hooks.onReady)
{
function 𝓟1608{$Lambda178} (): (𝓟1609: [OOV]any)
{
return 𝓟1609 = 𝓟1607{wrapped}
}
return 𝓟1606 = 𝓛23509{resolve}(𝓟[ty]1592{ModelHandlers}.model.hooks.onReady(𝓟1607{wrapped} as any as 𝓛[ty]2{<UNKNOWN>})).then(𝓟1608{$Lambda178})
}
return 𝓟1606 = 𝓟1607{wrapped}
}
return 𝓟1604 = 𝓛23509{resolve}(𝓛12592{AmpersandAmpersandToken}(𝓟[ty]1592{ModelHandlers}.model.hooks.onRetrieved,𝓟[ty]1592{ModelHandlers}.model.hooks.onRetrieved(𝓟1603{target}))).then(𝓟1605{$Lambda177}) as 𝓛[ty]2{<UNKNOWN>}
}
return 𝓟1600 = 𝓛23509{resolve}(𝓟[ty]1592{ModelHandlers}.model.helpers.transformFromDB(𝓟1597{result},{document: 𝓛8744{Boolean}})).then(𝓟1602{$Lambda176})
}
function 𝓟1610{creatingDocuments} (𝓟1611{documents}: 𝓛[ty]8670{Array}): (𝓟1612: [OOV]𝓛[ty]2{<UNKNOWN>})
{
function 𝓟1613{$Lambda179} (𝓟1614{document}: [OOV]any): (𝓟1615: [OOV]any)
{
function 𝓟1616{$Lambda180} (): (𝓟1617: [OOV]any)
{
𝓟1614{document} ⟵ 𝓟[ty]1592{ModelHandlers}.model.helpers.convertToDB(𝓟1614{document},{document: 𝓛8744{Boolean},properties: 𝓛8744{Boolean}});
let 𝓟1618{validation}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]1592{ModelHandlers}.model.helpers.validate(𝓟1614{document});
if (𝓟1618{validation}.failed)
{
return 𝓟1617 = 𝓛23512{reject}(𝓟1618{validation}.error)
}
return 𝓟1617 = 𝓟1614{document}
}
return 𝓟1615 = 𝓛23509{resolve}(𝓛12592{AmpersandAmpersandToken}(𝓟[ty]1592{ModelHandlers}.model.hooks.onCreating,𝓟[ty]1592{ModelHandlers}.model.hooks.onCreating(𝓟1614{document}))).then(𝓟1616{$Lambda180})
}
return 𝓟1612 = 𝓛23632{all}(𝓟1611{documents}.map(𝓟1613{$Lambda179}))
}
function 𝓟1619{savingDocument} (𝓟1620{instance}: [OOV]any,𝓟1621{changes}: [OOV]any): (𝓟1622: [OOV]𝓛[ty]2{<UNKNOWN>})
{
function 𝓟1623{$Lambda181} (): (𝓟1624: [OOV]any)
{
return 𝓟1624 = 𝓟1620{instance}
}
return 𝓟1622 = 𝓛23509{resolve}(𝓛12592{AmpersandAmpersandToken}(𝓟[ty]1592{ModelHandlers}.model.hooks.onSaving,𝓟[ty]1592{ModelHandlers}.model.hooks.onSaving(𝓟1620{instance},𝓟1621{changes}))).then(𝓟1623{$Lambda181})
}
}
Module: lib/ModelHelpers
type 𝓟[ty]1625{TransformOptions} = {properties: 𝓛[ty]8666{Boolean}, document: 𝓛[ty]8666{Boolean}}
function 𝓟1626{CONSTRUCTOR} (𝓟1627{model}: 𝓟[ty]947{Model}): (𝓟[ty]1634{ModelHelpers})
{
const 𝓟[ty]1634{ModelHelpers};
const 𝓟[ty]1634{ModelHelpers};
𝓟[ty]1634{ModelHelpers}.model ⟵ 𝓟1627{model};
𝓟[ty]1634{ModelHelpers}._validator ⟵ 𝓛1{<UNKNOWN>}(𝓟1627{model}.schema);
function 𝓟1631{$Lambda182} (𝓟1632{validator}): (𝓟1633: [OOV]any)
{
return 𝓟1633 = 𝓟[ty]1634{ModelHelpers}._validator.register(𝓟1632{validator})
}
𝓟1627{model}.validators.forEach(𝓟1631{$Lambda182})
}
class 𝓟[ty]1634{ModelHelpers}{
𝓟1636{model}: 𝓟[ty]947{Model};
𝓟1637{_validator}: [OOV]𝓛[ty]2{<UNKNOWN>};
function 𝓟1646{transformToDB} (𝓟1647{document}: [OOV]any,𝓟1648{options}: [OOV]𝓟[ty]1625{TransformOptions}): (𝓟1649: [OOV]any)
{
if (𝓛12592{AmpersandAmpersandToken}(𝓟1648{options}.document,𝓟[ty]1634{ModelHelpers}.model.transforms.$document))
{
𝓟1647{document} ⟵ 𝓟[ty]1634{ModelHelpers}.model.transforms.$document.toDB(𝓟1647{document},𝓛8743{String},𝓟[ty]1634{ModelHelpers}.model) as any;
}
if (𝓛12569{ExclamationToken}(𝓟1648{options}.properties))
{
return 𝓟1649 = 𝓟1647{document}
}
{
let 𝓟1650{property}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]1634{ModelHelpers}.model.transforms);
while (𝓛8744{Boolean})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1650{property},𝓛8743{String}))
{
}
const 𝓟1651{transform}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]1634{ModelHelpers}.model.transforms.access(𝓟1650{property});
if (𝓛12569{ExclamationToken}(𝓟1651{transform}))
{
}
if (𝓟1647{document}.hasOwnProperty(𝓟1650{property}))
{
𝓟1647{document} as any.access(𝓟1650{property}) ⟵ 𝓟1651{transform}.toDB(𝓟1647{document} as any.access(𝓟1650{property}),𝓟1650{property},𝓟[ty]1634{ModelHelpers}.model);
}
}
}
return 𝓟1649 = 𝓟1647{document}
}
function 𝓟1641{wrapDocument} (𝓟1642{document}: [OOV]any,𝓟1643{isNew}: 𝓛[ty]8666{Boolean},𝓟1644{isPartial}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8666{Boolean})): (𝓟1645: [OOV]any)
{
return 𝓟1645 = 𝓟[ty]1634{ModelHelpers}.model.Instance.CONSTRUCTOR(𝓟1642{document},𝓟1643{isNew},𝓟1644{isPartial})
}
function 𝓟1638{validate} (𝓟1639{document}: [OOV]any): (𝓟1640: [OOV]𝓛[ty]2{<UNKNOWN>})
{
return 𝓟1640 = 𝓟[ty]1634{ModelHelpers}._validator.validate(𝓟1639{document})
}
function 𝓟1658{convertToDB} (𝓟1659{document}: [OOV]any,𝓟1660{options}: [OOV]𝓟[ty]1625{TransformOptions}): (𝓟1661: [OOV]any)
{
let 𝓟1662{doc}: [OOV]any = 𝓟[ty]1634{ModelHelpers}.cloneDocument(𝓟1659{document});
return 𝓟1661 = 𝓟[ty]1634{ModelHelpers}.transformToDB(𝓟1662{doc},𝓟1660{options})
}
function 𝓟1663{diff} (𝓟1664{original}: [OOV]any,𝓟1665{modified}: [OOV]any): (𝓟1666: [OOV]any)
{
let 𝓟1667{omnom}: [miss]𝓟[ty]595{Omnom} = 𝓟565{CONSTRUCTOR}();
𝓟1667{omnom}.diff(𝓟1664{original},𝓟1665{modified})
return 𝓟1666 = 𝓟1667{omnom}.changes
}
function 𝓟1652{transformFromDB} (𝓟1653{document}: [OOV]any,𝓟1654{options}: [OOV]𝓟[ty]1625{TransformOptions}): (𝓟1655: [OOV]any)
{
if (𝓛12592{AmpersandAmpersandToken}(𝓟1654{options}.document,𝓟[ty]1634{ModelHelpers}.model.transforms.$document))
{
𝓟1653{document} ⟵ 𝓟[ty]1634{ModelHelpers}.model.transforms.$document.fromDB(𝓟1653{document},𝓛8743{String},𝓟[ty]1634{ModelHelpers}.model);
}
if (𝓛12569{ExclamationToken}(𝓟1654{options}.properties))
{
return 𝓟1655 = 𝓟1653{document}
}
{
let 𝓟1656{property}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]1634{ModelHelpers}.model.transforms);
while (𝓛8744{Boolean})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1656{property},𝓛8743{String}))
{
}
const 𝓟1657{transform}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]1634{ModelHelpers}.model.transforms.access(𝓟1656{property});
if (𝓛12569{ExclamationToken}(𝓟1657{transform}))
{
}
if (𝓟1653{document}.hasOwnProperty(𝓟1656{property}))
{
𝓟1653{document} as any.access(𝓟1656{property}) ⟵ 𝓟1657{transform}.fromDB(𝓟1653{document} as any.access(𝓟1656{property}),𝓟1656{property},𝓟[ty]1634{ModelHelpers}.model);
}
}
}
return 𝓟1655 = 𝓟1653{document}
}
function 𝓟1674{cloneConditions} (𝓟1675{original}: [OOV]any): (𝓟1676: [OOV]any)
{
return 𝓟1676 = 𝓟[ty]1634{ModelHelpers}.cloneDocument(𝓟1675{original})
}
function 𝓟1668{cloneDocument} (𝓟1669{original}: [OOV]any): (𝓟1670: [OOV]any)
{
function 𝓟1671{$Lambda183} (𝓟1672{value}): (𝓟1673: [OOV]any)
{
if (𝓛10100{Buffer}.isBuffer(𝓟1672{value}))
{
return 𝓟1673 = 𝓟1672{value}
}
if (𝓛1{<UNKNOWN>}(𝓟1672{value},𝓛1{<UNKNOWN>}))
{
return 𝓟1673 = 𝓟1672{value}
}
if (𝓛1{<UNKNOWN>}(𝓟1672{value},𝓛1{<UNKNOWN>}))
{
return 𝓟1673 = 𝓟1672{value}
}
}
return 𝓟1670 = 𝓛1{<UNKNOWN>}(𝓟1669{original},𝓟1671{$Lambda183})
}
}
Module: lib/Middleware
type 𝓟[ty]1677{MiddlewareFactory} = {call: (𝓟[ty]386{Core})->any}