tspl-cli 0.0.0-stage → 0.1.1

package/src/find/graph.js

@@ -0,0 +1,272 @@
+'use strict'
+
+const Path = require('path').posix
+
+const RESOLVE_EXTENSIONS = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '/index.ts', '/index.tsx', '/index.js', '/index.jsx', '/__init__.py']
+const ROUTE_NOISE = /^(api|v\d+)$/
+const KIND_SUFFIX = /\.(route|routes|router|controller|api|handler|handlers)$/
+
+const CONSTANT_NAME = /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)+$/
+const SAME_VALUE_MAX = 12
+
+const EDGE_WEIGHTS = {
+  'calls-api': 0.9,
+  'same-value': 0.7,
+  template: 0.9,
+  renders: 0.6,
+  imports: 0.6,
+  uses: 0.4,
+}
+
+const segments = url => {
+  const path = String(url)
+    .replace(/^[a-z]+:\/\/[^/]+/i, '')
+    .replace(/[?#].*$/, '')
+  return path
+    .split('/')
+    .filter(Boolean)
+    .map(part => (/[{}:*]/.test(part) || /^\d+$/.test(part) ? '*' : part.toLowerCase()))
+}
+
+const fileStem = path => Path.basename(path).replace(/\.[^.]+$/, '').replace(KIND_SUFFIX, '').toLowerCase()
+
+const repoKind = files => {
+  const ui = files.filter(file => {
+    const facts = file.facts
+    return facts.language === 'html' || facts.screens || facts.uiRoutes || facts.labels ||
+      (facts.components || []).some(component => component.kind === 'component')
+  }).length
+  const api = files.filter(file => file.facts.routes).length
+  if (ui >= 10 && ui >= api) return 'app'
+  if (api >= 5) return 'api'
+  return 'shared'
+}
+
+const createGraph = (index, feedback = {}) => {
+  const files = []
+  const byKey = new Map()
+  const repos = Object.entries(index.repos || {}).map(([id, repo]) => ({ id, ...repo }))
+
+  repos.forEach(repo => {
+    repo.paths = new Set()
+    repo.files
+      .filter(file => file.status === 'parsed' && repo.facts[file.blobHash])
+      .forEach(file => {
+        const node = {
+          id: files.length,
+          repo: repo.name,
+          repoId: repo.id,
+          path: file.path,
+          facts: repo.facts[file.blobHash],
+          history: [
+            ...((repo.history && repo.history[file.path]) || []),
+            ...(feedback[`${repo.name}/${file.path}`] || []),
+          ],
+        }
+        files.push(node)
+        byKey.set(`${repo.id}\0${file.path}`, node)
+        repo.paths.add(file.path)
+      })
+  })
+
+  const out = files.map(() => [])
+  const into = files.map(() => [])
+  const seen = new Set()
+  const addEdge = (from, to, type, detail) => {
+    if (!to || from.id === to.id) return
+    const key = `${from.id}>${to.id}`
+    if (seen.has(key)) return
+    seen.add(key)
+    const edge = { from: from.id, to: to.id, type, detail: detail || null, weight: EDGE_WEIGHTS[type] }
+    out[from.id].push(edge)
+    into[to.id].push(edge)
+  }
+
+  const byPackage = new Map(repos.filter(repo => repo.packageName).map(repo => [repo.packageName, repo]))
+
+  const findIn = (repo, path) => {
+    const clean = Path.normalize(path).replace(/^\.\//, '').replace(/\/$/, '')
+    for (const ext of RESOLVE_EXTENSIONS) {
+      if (repo.paths.has(clean + ext)) return byKey.get(`${repo.id}\0${clean + ext}`)
+    }
+    return null
+  }
+
+  const fromPackage = spec => {
+    const parts = spec.split('/')
+    const name = spec.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]
+    const repo = byPackage.get(name)
+    if (!repo) return null
+    const rest = spec.slice(name.length).replace(/^\//, '')
+    return findIn(repo, rest || repo.packageMain || 'index')
+  }
+
+  const inRepo = (repo, target) => {
+    const vendored = target.match(/^node_modules\/((?:@[^/]+\/)?[^/]+)(?:\/(.*))?$/)
+    if (vendored) return fromPackage(vendored[2] ? `${vendored[1]}/${vendored[2]}` : vendored[1])
+    return findIn(repo, target)
+  }
+
+  const resolveImport = (repo, file, spec) => {
+    if (spec.startsWith('.')) {
+      return findIn(repo, Path.join(Path.dirname(file.path), spec))
+    }
+    for (const alias of repo.aliases || []) {
+      if (alias.wildcard ? spec.startsWith(alias.from) : spec === alias.from || spec.startsWith(`${alias.from}/`)) {
+        return inRepo(repo, Path.join(alias.to, spec.slice(alias.from.length)))
+      }
+    }
+    if (file.facts.language === 'python' && /^[\w.]+$/.test(spec)) {
+      const asPath = spec.replace(/\./g, '/')
+      return findIn(repo, asPath) || findIn(repo, Path.join(Path.dirname(file.path), asPath))
+    }
+    return fromPackage(spec)
+  }
+
+  const repoById = new Map(repos.map(repo => [repo.id, repo]))
+  files.forEach(file => {
+    const repo = repoById.get(file.repoId)
+    ;(file.facts.imports || []).forEach(spec => addEdge(file, resolveImport(repo, file, spec), 'imports', spec))
+  })
+
+  const dependsOn = new Map(repos.map(repo => [repo.id, new Set([repo.id])]))
+  out.flat().forEach(edge => dependsOn.get(files[edge.from].repoId).add(files[edge.to].repoId))
+  const nearest = (file, candidates) => {
+    if (!candidates) return []
+    const list = [...candidates]
+    const local = list.filter(target => target.repoId === file.repoId)
+    return local.length ? local : list.filter(target => dependsOn.get(file.repoId).has(target.repoId))
+  }
+
+  const selectors = new Map()
+  const definitions = new Map()
+  const remember = (map, key, file) => {
+    if (!map.has(key)) map.set(key, new Set())
+    map.get(key).add(file)
+  }
+  const define = (name, file) => {
+    if (name && name.length >= 4 && name !== 'default') remember(definitions, name.toLowerCase(), file)
+  }
+  files.forEach(file => {
+    const facts = file.facts
+    ;(facts.symbols || []).forEach(symbol => define(symbol.name, file))
+    ;(facts.models || []).forEach(model => define(model.name, file))
+    ;(facts.values || []).filter(value => CONSTANT_NAME.test(value.name)).forEach(value => define(value.name, file))
+    ;(facts.components || []).forEach(component => {
+      define(component.name, file)
+      if (component.selector) {
+        component.selector.split(',').forEach(selector => remember(selectors, selector.trim(), file))
+      }
+      if (component.template) {
+        const repo = repoById.get(file.repoId)
+        addEdge(file, findIn(repo, Path.join(Path.dirname(file.path), component.template)), 'template', component.template)
+      }
+    })
+  })
+
+  files.forEach(file => {
+    ;(file.facts.tags || []).forEach(tag => {
+      const targets = nearest(file, selectors.get(tag))
+      if (targets.length === 1) addEdge(file, targets[0], 'renders', `<${tag}>`)
+    })
+    ;(file.facts.refs || []).forEach(name => {
+      const targets = nearest(file, definitions.get(name.toLowerCase()))
+      if (targets.length && targets.length <= 2) targets.forEach(target => addEdge(file, target, 'uses', name))
+    })
+  })
+
+  const setters = new Map()
+  files.forEach(file => {
+    new Set((file.facts.values || []).filter(value => CONSTANT_NAME.test(value.name)).map(value => value.name))
+      .forEach(name => remember(setters, `${file.repoId}\0${name}`, file))
+  })
+  setters.forEach((group, key) => {
+    if (group.size < 2 || group.size > SAME_VALUE_MAX) return
+    const name = key.split('\0')[1]
+    const list = [...group]
+    list.forEach(a => list.forEach(b => a.id < b.id && addEdge(a, b, 'same-value', name)))
+  })
+
+  const routes = []
+  files.forEach(file => {
+    ;(file.facts.routes || []).forEach(route => {
+      const parts = segments(route.path)
+      if (!parts.length) return
+      routes.push({ file, route, parts, methods: route.method.split(','), stem: fileStem(file.path) })
+    })
+  })
+
+  const matchCall = (file, call) => {
+    const parts = segments(call.url)
+    if (!parts.some(part => part !== '*')) return []
+    let best = []
+    let bestScore = 0
+    routes.forEach(candidate => {
+      if (!candidate.methods.includes(call.method) && !candidate.methods.includes('*')) return
+      const tail = candidate.parts
+      if (tail.length > parts.length) return
+      const offset = parts.length - tail.length
+      let literal = 0
+      for (let i = 0; i < tail.length; i++) {
+        const want = parts[offset + i]
+        if (tail[i] === '*') continue
+        if (want !== tail[i]) return
+        literal += 1
+      }
+      const head = parts.slice(0, offset).filter(part => part !== '*' && !ROUTE_NOISE.test(part))
+      let score = literal * 2 + (tail.length === parts.length ? 1 : 0)
+      if (head.length) {
+        const joined = head.join('-')
+        if (joined === candidate.stem) {
+          score += 3
+        } else if (candidate.stem.endsWith(joined) || joined.endsWith(candidate.stem)) {
+          score += 2
+        } else if (literal < 2) {
+          return
+        } else {
+          score -= 1
+        }
+      }
+      if (score > bestScore) {
+        bestScore = score
+        best = [candidate]
+      } else if (score === bestScore) {
+        best.push(candidate)
+      }
+    })
+    return best
+  }
+
+  const pending = []
+  const affinity = new Map()
+  files.forEach(file => {
+    ;(file.facts.httpCalls || []).forEach(call => {
+      const matches = matchCall(file, call)
+      if (!matches.length) return
+      pending.push({ file, call, matches })
+      new Set(matches.map(match => match.file.repoId)).forEach(repoId => {
+        const key = `${file.repoId}>${repoId}`
+        affinity.set(key, (affinity.get(key) || 0) + 1 / matches.length)
+      })
+    })
+  })
+  pending.forEach(({ file, call, matches }) => {
+    const strength = match => affinity.get(`${file.repoId}>${match.file.repoId}`) || 0
+    const top = Math.max(...matches.map(strength))
+    matches
+      .filter(match => strength(match) === top)
+      .slice(0, 3)
+      .forEach(match => addEdge(file, match.file, 'calls-api', `${call.method} ${call.url}`))
+  })
+
+  repos.forEach(repo => {
+    repo.kind = repoKind(files.filter(file => file.repoId === repo.id))
+  })
+
+  return { files, out, into, repos }
+}
+
+module.exports = {
+  createGraph,
+  segments,
+}