2022-01-17 17:41:17 +00:00
|
|
|
function trust ({ boss, models }) {
|
|
|
|
return async function () {
|
2022-01-17 21:47:26 +00:00
|
|
|
console.log('doing trust')
|
|
|
|
const graph = await getGraph(models)
|
2022-01-18 17:13:55 +00:00
|
|
|
const user = await models.user.findUnique({ where: { name: process.env.WOT_SOURCE || 'k00b' } })
|
|
|
|
const trust = await trustGivenGraph(graph, user.id)
|
2022-01-17 21:47:26 +00:00
|
|
|
await storeTrust(models, trust)
|
|
|
|
console.log('done doing trust')
|
2022-01-17 17:41:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-17 21:47:26 +00:00
|
|
|
// only explore a path up to this depth from start
|
|
|
|
const MAX_DEPTH = 6
|
|
|
|
const MAX_TRUST = 0.9
|
|
|
|
|
|
|
|
function pathsOverlap (arr1 = [], arr2 = []) {
|
|
|
|
const dp = new Array(arr1.length + 1).fill(0).map(() => new Array(arr2.length + 1).fill(0))
|
|
|
|
for (let i = arr1.length - 1; i >= 0; i--) {
|
|
|
|
for (let j = arr2.length - 1; j >= 0; j--) {
|
|
|
|
if (arr1[i] === arr2[j]) {
|
|
|
|
dp[i][j] = dp[i + 1][j + 1] + 1
|
|
|
|
if (dp[i][j] > 1) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
dp[i][j] = 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
This approximates an upper bound of trust given a list of indepent trust
|
|
|
|
values ... we basically are compressing a trust vector into a single value
|
|
|
|
without having to compute the trust using the inclusion-exclusion principle
|
|
|
|
*/
|
|
|
|
function boundedTrust (probs) {
|
|
|
|
const max = Math.max(...probs)
|
|
|
|
const sum = probs.reduce((a, c) => a + c)
|
|
|
|
const trust = sum - max * (sum - max)
|
|
|
|
return Math.min(trust, MAX_TRUST)
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Given the paths to each node and the accumulated trust along that path
|
|
|
|
this function returns an object where the keys are the node ids and
|
|
|
|
their value is the trust of that node
|
|
|
|
*/
|
|
|
|
function trustGivenPaths (paths) {
|
|
|
|
const trust = {}
|
|
|
|
for (const [node, npaths] of Object.entries(paths)) {
|
|
|
|
trust[node] = boundedTrust(Object.values(npaths))
|
|
|
|
}
|
|
|
|
return trust
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Given a graph and start this function returns an object where
|
|
|
|
the keys are the node id and their value is the trust of that node
|
|
|
|
*/
|
|
|
|
function trustGivenGraph (graph, start) {
|
|
|
|
const queue = [] // queue of to be visited nodes
|
|
|
|
queue.push(start) // visit start first
|
|
|
|
|
|
|
|
const depth = {} // store the node depth ... XXX space inefficient
|
|
|
|
depth[start] = 0 // start node is depth 0
|
|
|
|
|
|
|
|
const paths = {} // { node : { path to node as stringified json array : trust } }
|
|
|
|
paths[start] = { '[]': 1 } // the paths to start is an empty path with trust of 1
|
|
|
|
|
|
|
|
// while we have nodes to visit
|
|
|
|
while (queue.length > 0) {
|
|
|
|
const node = queue.shift()
|
|
|
|
if (depth[node] === MAX_DEPTH) break
|
|
|
|
|
|
|
|
if (!graph[node]) {
|
|
|
|
// node doesn't have outbound edges
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// for all of this nodes outbound edges
|
|
|
|
for (let i = 0; i < graph[node].length; i++) {
|
|
|
|
const { node: sibling, trust } = graph[node][i]
|
|
|
|
let explore = false
|
|
|
|
|
|
|
|
// for all existing paths to this node
|
|
|
|
for (const [key, value] of Object.entries(paths[node])) {
|
|
|
|
const parentPath = JSON.parse(key)
|
|
|
|
if (parentPath.includes(sibling)) {
|
|
|
|
// sibling already exists on a path to us, ie this would be a cycle
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// add this path to sibling
|
|
|
|
const path = JSON.stringify([...parentPath, node])
|
|
|
|
paths[sibling] = paths[sibling] || {}
|
|
|
|
|
|
|
|
// if this sibling has not been visited along this path
|
|
|
|
if (!paths[sibling][path]) {
|
|
|
|
// here we exclude paths that aren't disjoint - they mininally contribute
|
|
|
|
// to trust so we just exclude them, yielding a very small underestimation
|
|
|
|
// of trust while reducing the number of paths we have to explore
|
|
|
|
let disjoint = true
|
|
|
|
// for all the paths to sibling
|
|
|
|
for (const [key2] of Object.entries(paths[sibling])) {
|
|
|
|
// if this existing path to sibling contains overlap with the
|
|
|
|
// path we're exploring, ignore it
|
|
|
|
const otherPath = JSON.parse(key2)
|
|
|
|
const parsedPath = JSON.parse(path)
|
|
|
|
if (pathsOverlap(otherPath, parsedPath)) {
|
|
|
|
disjoint = false
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// if this path is disjoint with all existing paths to sibling
|
|
|
|
if (disjoint) {
|
|
|
|
// accumulate the trust along the path and store it
|
|
|
|
paths[sibling][path] = value * trust
|
|
|
|
explore = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// if we shouldn't explore this sibling, don't queue it
|
|
|
|
if (!explore) continue
|
|
|
|
depth[sibling] = depth[node] + 1
|
|
|
|
queue.push(sibling)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return trustGivenPaths(paths)
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
graph is returned as json in adjacency list where edges are the trust value 0-.9
|
|
|
|
graph = {
|
|
|
|
node1 : [{node : node2, trust: trust12}, {node: node3, trust: trust13}],
|
|
|
|
node2 : [{node : node1, trust: trust21}],
|
|
|
|
node3 : [{node : node2, trust: trust32}],
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
async function getGraph (models) {
|
|
|
|
const [{ graph }] = await models.$queryRaw`
|
|
|
|
select json_object_agg(id, hops) as graph
|
|
|
|
from (
|
|
|
|
select id, json_agg(json_build_object('node', oid, 'trust', trust)) as hops
|
|
|
|
from (
|
2022-03-31 16:31:37 +00:00
|
|
|
select "ItemAct"."userId" as id, "Item"."userId" as oid, least(${MAX_TRUST},
|
2022-04-02 22:42:06 +00:00
|
|
|
sum(POWER(.99, EXTRACT(DAY FROM (NOW_UTC() - "ItemAct".created_at))))/21.0) as trust
|
2022-01-17 21:47:26 +00:00
|
|
|
from "ItemAct"
|
|
|
|
join "Item" on "itemId" = "Item".id and "ItemAct"."userId" <> "Item"."userId"
|
|
|
|
where "ItemAct".act = 'VOTE' group by "ItemAct"."userId", "Item"."userId"
|
|
|
|
) a
|
|
|
|
group by id
|
|
|
|
) b`
|
|
|
|
return graph
|
|
|
|
}
|
|
|
|
|
|
|
|
async function storeTrust (models, nodeTrust) {
|
|
|
|
// convert nodeTrust into table literal string
|
|
|
|
let values = ''
|
|
|
|
for (const [id, trust] of Object.entries(nodeTrust)) {
|
|
|
|
if (values) values += ','
|
|
|
|
values += `(${id}, ${trust})`
|
|
|
|
}
|
|
|
|
|
|
|
|
// update the trust of each user in graph
|
2022-03-31 16:31:37 +00:00
|
|
|
await models.$transaction([
|
|
|
|
models.$executeRaw`UPDATE users SET trust = 0`,
|
|
|
|
models.$executeRaw(
|
|
|
|
`UPDATE users
|
|
|
|
SET trust = g.trust
|
|
|
|
FROM (values ${values}) g(id, trust)
|
|
|
|
WHERE users.id = g.id`)])
|
2022-01-17 21:47:26 +00:00
|
|
|
}
|
|
|
|
|
2022-01-17 17:41:17 +00:00
|
|
|
module.exports = { trust }
|