repluggable-core 0.0.0-pr280.413 → 0.0.0-pr282.418

package/src/repluggableAppDebug/performanceDebugInfo.ts

@@ -0,0 +1,96 @@
+import _ from 'lodash'
+import { AppHostOptions, Trace, StatisticsMemoization } from '../API'
+
+export function getPerformanceDebug(options: AppHostOptions, trace: Trace[], memoized: StatisticsMemoization[]) {
+    const getMemoizedTable = () => {
+        return _.map(memoized, memoize => {
+            const { calls, hit, miss } = memoize.func
+            const hitRate = `${((hit / calls) * 100).toFixed(2)}%`
+            const { name } = memoize
+            return { name, hitRate, calls, hit, miss }
+        })
+    }
+
+    const getGroups = (apiName: string) => {
+        const api = _.groupBy(trace, 'name')[apiName]
+        try {
+            const groupedArgs = _.groupBy(api, a => JSON.stringify(a.args))
+            const groupedRes = _.groupBy(api, a => JSON.stringify(a.res))
+            const groupedArgsAndRes = _.groupBy(api, a => JSON.stringify(a.args) + JSON.stringify(a.res))
+            return { groupedArgs, groupedRes, groupedArgsAndRes }
+        } catch (err) {
+            return { groupedArgs: [], groupedRes: [], groupedArgsAndRes: [] }
+        }
+    }
+    const printMemoizeTable = () => {
+        console.table(getMemoizedTable())
+    }
+    return {
+        getSortedMeasurments: () => {
+            return _(trace)
+                .map(measurement => _.pick(measurement, ['name', 'duration']))
+                .sortBy('duration')
+                .reverse()
+                .value()
+        },
+        start: () => {
+            if (!options.monitoring.disableMonitoring) {
+                options.monitoring.enablePerformance = true
+            } else {
+                console.log('Remove "disableMonitoring" in order to use trace')
+            }
+        },
+        stop: () => {
+            options.monitoring.enablePerformance = false
+        },
+        clean: () => {
+            trace.length = 0
+        },
+        getTrace: () => {
+            return trace
+        },
+        getGroupedTrace: () => {
+            return _.groupBy(trace, 'name')
+        },
+        getGroupedSumTrace: () => {
+            const traceData = _(trace)
+                .groupBy('name')
+                .mapValues((arr, name) => {
+                    const totalDuration = Number(_.sumBy(arr, 'duration').toFixed(2))
+                    const times = arr.length
+                    const avgDuration = Number((totalDuration / times).toFixed(2))
+                    const groups = _(getGroups(name))
+                        .mapValues((obj, group) => {
+                            const keys = Object.keys(obj)
+                            const length = keys.length
+                            if (group !== 'groupedRes' || length === 0) {
+                                return length
+                            }
+                            const joined = keys.join(' ')
+                            return joined.length < 15 ? `${length}: ${joined}` : length
+                        })
+                        .value()
+
+                    return { name, times, totalDuration, avgDuration, ...groups }
+                })
+                .orderBy(x => x.totalDuration, 'desc')
+                .value()
+
+            _.forEach(getMemoizedTable(), memoizeData => {
+                _.assign(_.find(traceData, { name: memoizeData.name }), memoizeData)
+            })
+            console.table(traceData)
+        },
+        analyseAPI: (apiName: string) => {
+            const groups = getGroups(apiName)
+            if (groups) {
+                const { groupedArgs, groupedRes, groupedArgsAndRes } = groups
+                console.log(`groupedArgs: ${Object.keys(groupedArgs).length}`, groupedArgs)
+                console.log(`groupedRes: ${Object.keys(groupedRes).length}`, groupedRes)
+                console.log(`groupedArgsAndRes: ${Object.keys(groupedArgsAndRes).length}`, groupedArgsAndRes)
+            }
+        },
+        getMemoized: () => memoized,
+        printMemoizeTable
+    }
+}

package/src/repluggableAppDebug/repluggableAppDebug.ts

@@ -0,0 +1,192 @@
+import { getPerformanceDebug } from './performanceDebugInfo'
+import { AnySlotKey, AppHost, EntryPoint, LazyEntryPointFactory, PrivateShell, SlotKey, StatisticsMemoization, Trace } from '../API'
+import _ from 'lodash'
+import { hot } from '../hot'
+import { AppHostServicesProvider } from '../appHostServices'
+import { AnyExtensionSlot } from '../extensionSlot'
+
+interface PerformanceDebugParams {
+    options: AppHost['options']
+    trace: Trace[]
+    memoizedArr: StatisticsMemoization[]
+}
+
+interface SetupDebugInfoParams {
+    readyAPIs: Set<AnySlotKey>
+    host: AppHost & AppHostServicesProvider
+    uniqueShellNames: Set<string>
+    extensionSlots: Map<AnySlotKey, AnyExtensionSlot>
+    addedShells: Map<string, PrivateShell>
+    shellInstallers: WeakMap<PrivateShell, string[]>
+    lazyShells: Map<string, LazyEntryPointFactory>
+
+    performance: PerformanceDebugParams
+
+    getUnreadyEntryPoints(): EntryPoint[]
+    getOwnSlotKey(key: SlotKey<any>): SlotKey<any>
+    getAPI: AppHost['getAPI']
+}
+
+function mapApiToEntryPoint(allPackages: EntryPoint[]) {
+    const apiToEntryPoint = new Map<string, EntryPoint | undefined>()
+    _.forEach(allPackages, (entryPoint: EntryPoint) => {
+        _.forEach(entryPoint.declareAPIs ? entryPoint.declareAPIs() : [], dependency => {
+            apiToEntryPoint.set(dependency.name, entryPoint)
+        })
+    })
+    return apiToEntryPoint
+}
+
+/**
+ * a function that returns all the entry points in the system with their declared APIs and dependencies
+ */
+const getAllEntryPoints = () => {
+    return [
+        ...globalThis.repluggableAppDebug.utils.unReadyEntryPoints(),
+        ...[...globalThis.repluggableAppDebug.addedShells].map(([_, shell]) => shell.entryPoint)
+    ]
+}
+
+/**
+ * this function is used to get the root unready API in case there are too many to understand.
+ * for example if you have 200 unready entry points, running this function will give you the first unready API that
+ * will unblock the rest of the entry point (note that there might be more than one)
+ *
+ * this function basically takes the first unready entry point, get its dependencies and iterates over them to find an API that is not ready
+ * at this point it follows the same process recursively until it reaced the target API.
+ */
+const getRootUnreadyAPI = (host: AppHost) => {
+    return () => {
+        // get all unready entry points
+        const allEntryPoints = getAllEntryPoints()
+        const unReadyAPIsArray = []
+        // get the depdenencies of the first unready entry point
+        let dependenciesOfUnreadyEntryPoint = allEntryPoints?.[0]?.getDependencyAPIs?.()
+
+        while (dependenciesOfUnreadyEntryPoint?.length) {
+            const currentAPI = dependenciesOfUnreadyEntryPoint.pop()
+
+            if (!currentAPI) {
+                continue
+            }
+            // try to get the API from this host, we are looking for an API that is not ready
+            try {
+                const api = host.getAPI(currentAPI as SlotKey<any>)
+                if (api) {
+                    continue
+                }
+            } catch (e) {
+                unReadyAPIsArray.push(currentAPI)
+                // we found an API that is unready, lets find which entry point declares it
+                const declarer = allEntryPoints.find(entryPointData =>
+                    entryPointData.declareAPIs?.().some(api => currentAPI?.name === api.name)
+                )
+                dependenciesOfUnreadyEntryPoint = declarer?.getDependencyAPIs?.()
+            }
+        }
+        return unReadyAPIsArray.reverse()
+    }
+}
+
+const getAPIOrEntryPointsDependencies = (
+    apisOrEntryPointsNames: string[],
+    entryPoints: EntryPoint[]
+): { entryPoints: EntryPoint[]; apis: AnySlotKey[] } => {
+    const apiToEntryPoint = mapApiToEntryPoint(entryPoints)
+
+    const loadedEntryPoints = new Set<string>()
+    const packagesList: EntryPoint[] = []
+    const allDependencies = new Set<AnySlotKey>()
+    const apisOrEntryPointsSet = new Set(apisOrEntryPointsNames)
+    const entryPointsQueue: EntryPoint[] = entryPoints.filter(x => apisOrEntryPointsSet.has(x.name))
+
+    apisOrEntryPointsNames.forEach(x => {
+        const ep = apiToEntryPoint.get(x)
+        ep && entryPointsQueue.push(ep)
+    })
+
+    while (entryPointsQueue.length) {
+        const currEntryPoint = entryPointsQueue.shift()
+        if (!currEntryPoint || loadedEntryPoints.has(currEntryPoint.name)) {
+            continue
+        }
+        loadedEntryPoints.add(currEntryPoint.name)
+        packagesList.push(currEntryPoint)
+        const dependencies = currEntryPoint.getDependencyAPIs ? currEntryPoint.getDependencyAPIs() : []
+        dependencies.forEach(x => allDependencies.add(x))
+        const dependencyEntryPoints = dependencies.map((API: AnySlotKey) => apiToEntryPoint.get(API.name))
+        entryPointsQueue.push(..._.compact(dependencyEntryPoints))
+    }
+
+    return {
+        entryPoints: packagesList,
+        apis: [...allDependencies]
+    }
+}
+
+export function setupDebugInfo({
+    host,
+    uniqueShellNames,
+    readyAPIs,
+    getAPI,
+    getOwnSlotKey,
+    getUnreadyEntryPoints,
+    extensionSlots,
+    addedShells,
+    lazyShells,
+    shellInstallers,
+    performance: { options, trace, memoizedArr }
+}: SetupDebugInfoParams) {
+    const utils = {
+        apis: () => {
+            return Array.from(readyAPIs).map((apiKey: AnySlotKey) => {
+                return {
+                    key: apiKey,
+                    impl: () => getAPI(apiKey)
+                }
+            })
+        },
+        getRootUnreadyAPI: getRootUnreadyAPI(host),
+        unReadyEntryPoints: (): EntryPoint[] => getUnreadyEntryPoints(),
+        whyEntryPointUnready: (name: string) => {
+            const unreadyEntryPoint = _.find(
+                utils.unReadyEntryPoints(),
+                (entryPoint: EntryPoint) => entryPoint.name.toLowerCase() === name.toLowerCase()
+            )
+
+            const dependencies = _.invoke(unreadyEntryPoint, 'getDependencyAPIs')
+
+            const unreadyDependencies = _.filter(dependencies, key => !readyAPIs.has(getOwnSlotKey(key)))
+            if (!_.isEmpty(unreadyDependencies)) {
+                const unreadyDependenciesNames = _(unreadyDependencies).map('name').join(',')
+                console.log(`There are unready dependencies for ${name}: ${unreadyDependenciesNames}`)
+            }
+        },
+        findAPI: (name: string) => {
+            return _.filter(utils.apis(), (api: any) => api.key.name.toLowerCase().indexOf(name.toLowerCase()) !== -1)
+        },
+        getAPIOrEntryPointsDependencies: (
+            apisOrEntryPointsNames: string[],
+            entryPoints = [...addedShells.values()].map(x => x.entryPoint)
+        ) => getAPIOrEntryPointsDependencies(apisOrEntryPointsNames, entryPoints),
+        performance: getPerformanceDebug(options, trace, memoizedArr)
+    }
+
+    if (typeof globalThis === 'undefined') {
+        return
+    }
+
+    globalThis.repluggableAppDebug = {
+        host,
+        uniqueShellNames,
+        extensionSlots,
+        addedShells,
+        lazyShells,
+        readyAPIs,
+        shellInstallers,
+        utils,
+        hmr: {
+            hot
+        }
+    }
+}

package/src/tarjanGraph.ts

@@ -0,0 +1,96 @@
+/*
+    Based on:
+    https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+    https://gist.github.com/chadhutchins/1440602
+*/
+
+export class Graph {
+    private readonly map = new Map<string, Vertex>()
+    private addOrGetVertex(value: string) {
+        let vertex = this.map.get(value)
+        if (!vertex) {
+            vertex = new Vertex(value)
+            this.map.set(value, vertex)
+        }
+        return vertex
+    }
+
+    getVertices() {
+        return this.map.values()
+    }
+
+    addConnection(source: string, target: string) {
+        this.addOrGetVertex(source).connections.push(this.addOrGetVertex(target))
+    }
+}
+
+class Vertex {
+    connections: Vertex[] = []
+    index = -1
+    lowLink = -1
+    constructor(public name: string) {}
+}
+
+export function getCycle(dependentGraph: { [key: string]: string[] }) {
+    let queue = Object.keys(dependentGraph).map(node => [node])
+    while (queue.length) {
+        const batch = []
+        for (const path of queue) {
+            const parents = dependentGraph[path[0]] || []
+            for (const node of parents) {
+                if (node === path[path.length - 1]) {
+                    return [node, ...path]
+                }
+                batch.push([node, ...path])
+            }
+        }
+        queue = batch
+    }
+}
+
+export class Tarjan {
+    private index = 0
+    private readonly stack: Vertex[] = []
+    private readonly scc: Vertex[][] = []
+    constructor(private readonly graph: Graph) {}
+
+    run() {
+        for (const v of this.graph.getVertices()) {
+            if (v.index < 0) {
+                this.strongConnect(v)
+            }
+        }
+        return this.scc
+    }
+
+    private strongConnect(vertex: Vertex) {
+        vertex.index = this.index
+        vertex.lowLink = this.index
+        this.index = this.index + 1
+        this.stack.push(vertex)
+
+        for (const w of vertex.connections) {
+            const v = vertex
+            if (w.index < 0) {
+                this.strongConnect(w)
+                v.lowLink = Math.min(v.lowLink, w.lowLink)
+            } else if (this.stack.some(x => x.name === w.name)) {
+                v.lowLink = Math.min(v.lowLink, w.index)
+            }
+        }
+
+        if (vertex.lowLink === vertex.index) {
+            const vertices = []
+            let w = null
+            if (this.stack.length > 0) {
+                do {
+                    w = this.stack.pop()
+                    w && vertices.push(w)
+                } while (vertex.name !== w?.name)
+            }
+            if (vertices.length > 0) {
+                this.scc.push(vertices)
+            }
+        }
+    }
+}