@getmikk/core 1.8.2 → 1.9.0

package/tests/impact-classified.test.ts

@@ -1,78 +1,74 @@
 import { describe, it, expect } from 'bun:test'
 import { ImpactAnalyzer } from '../src/graph/impact-analyzer'
 import { buildTestGraph } from './helpers'
-import { GraphBuilder } from '../src/graph/graph-builder'
 
 describe('ImpactAnalyzer - Classified', () => {
 
     it('classifies impacts based on depth and module boundaries', () => {
-        // Build graph with module boundaries:
-        // A (module: m1) calls B (module: m1) calls C (module: m2) calls D (module: m3)
-        // We are changing D. What is the impact?
-        // D is changed
-        // C is depth 1, crosses boundary -> CRITICAL
-        // B is depth 2 -> MEDIUM
-        // A is depth 3 -> LOW
-
+        // Calibration for Mikk 2.0 Quantitative Risk:
+        // AuthService (Auth keyword: 30) calls BStateAuthDB (State+Auth+DB keywords: 60) calls DBManager (m2, DB keyword: 20) calls PublicAPI (m3)
+        
         const graph = buildTestGraph([
-            ['A', 'B'],
-            ['B', 'C'],
-            ['C', 'D'],
-            ['D', 'nothing']
+            ['AuthService', 'BStateAuthDB'],
+            ['BStateAuthDB', 'DBManager'],
+            ['DBManager', 'PublicAPI'],
+            ['PublicAPI', 'nothing']
         ])
 
         // Assign modules manually for the test
-        graph.nodes.get('src/A.ts')!.moduleId = 'm1'
-        graph.nodes.get('fn:src/A.ts:A')!.moduleId = 'm1'
-
-        graph.nodes.get('src/B.ts')!.moduleId = 'm1'
-        graph.nodes.get('fn:src/B.ts:B')!.moduleId = 'm1'
-
-        graph.nodes.get('src/C.ts')!.moduleId = 'm2'
-        graph.nodes.get('fn:src/C.ts:C')!.moduleId = 'm2'
-
-        graph.nodes.get('src/D.ts')!.moduleId = 'm3'
-        graph.nodes.get('fn:src/D.ts:D')!.moduleId = 'm3'
+        for (const id of graph.nodes.keys()) {
+            if (id.includes('authservice')) graph.nodes.get(id)!.moduleId = 'm1'
+            if (id.includes('bstateauthdb')) {
+                graph.nodes.get(id)!.moduleId = 'm1'
+                graph.nodes.get(id)!.metadata!.isExported = true 
+            }
+            if (id.includes('dbmanager')) graph.nodes.get(id)!.moduleId = 'm2'
+            if (id.includes('publicapi')) graph.nodes.get(id)!.moduleId = 'm3'
+        }
 
         const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/D.ts:D'])
+        const result = analyzer.analyze(['fn:src/publicapi.ts:publicapi'])
 
         expect(result.impacted.length).toBe(3)
 
+        // Critical: DBManager (boosted to 80)
         expect(result.classified.critical).toHaveLength(1)
-        expect(result.classified.critical[0].nodeId).toBe('fn:src/C.ts:C')
-
-        expect(result.classified.high).toHaveLength(0) // No depth 1 in same module
+        expect(result.classified.critical[0].nodeId).toBe('fn:src/dbmanager.ts:dbmanager')
 
-        expect(result.classified.medium).toHaveLength(1)
-        expect(result.classified.medium[0].nodeId).toBe('fn:src/B.ts:B')
+        // High: BStateAuthDB (depth 2)
+        // Base: 3.5 + Auth(30) + DB(20) + Exported(15) = 68.5 -> HIGH.
+        expect(result.classified.high).toHaveLength(1)
+        expect(result.classified.high[0].nodeId).toBe('fn:src/bstateauthdb.ts:bstateauthdb')
 
+        // Low: AuthService (30 risk)
         expect(result.classified.low).toHaveLength(1)
-        expect(result.classified.low[0].nodeId).toBe('fn:src/A.ts:A')
+        expect(result.classified.low[0].nodeId).toBe('fn:src/authservice.ts:authservice')
     })
 
     it('classifies same-module depth-1 impact as HIGH, not CRITICAL', () => {
-        // E (module: m4) calls F (module: m4) calls G (module: m4)
-        // change G
-        // F is depth 1, same module -> HIGH
-        // E is depth 2 -> MEDIUM
+        // HighRiskAuthService calls AuthDBInstance calls G
         const graph = buildTestGraph([
-            ['E', 'F'],
-            ['F', 'G'],
+            ['HighRiskAuthService', 'AuthDBInstance'],
+            ['AuthDBInstance', 'G'],
             ['G', 'nothing']
         ])
 
         for (const id of graph.nodes.keys()) {
             graph.nodes.get(id)!.moduleId = 'm4'
+            if (id.includes('authdbinstance')) {
+                graph.nodes.get(id)!.metadata!.isExported = true
+            }
         }
 
         const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/G.ts:G'])
+        const result = analyzer.analyze(['fn:src/g.ts:g'])
 
         expect(result.classified.critical).toHaveLength(0)
         expect(result.classified.high).toHaveLength(1)
-        expect(result.classified.high[0].nodeId).toBe('fn:src/F.ts:F') // depth 1
-        expect(result.classified.medium).toHaveLength(1)
-        expect(result.classified.medium[0].nodeId).toBe('fn:src/E.ts:E') // depth 2
+        expect(result.classified.high[0].nodeId).toBe('fn:src/authdbinstance.ts:authdbinstance') 
+        
+        // HighRiskAuthService: depth 2, risk score 35.5 -> LOW
+        expect(result.classified.low).toHaveLength(1)
+        expect(result.classified.low[0].nodeId).toBe('fn:src/highriskauthservice.ts:highriskauthservice')
     })
 })

package/tests/parser.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'bun:test'
 import { TypeScriptParser } from '../src/parser/typescript/ts-parser'
+import { OxcParser } from '../src/parser/oxc-parser'
 import { TypeScriptExtractor } from '../src/parser/typescript/ts-extractor'
 import { TypeScriptResolver } from '../src/parser/typescript/ts-resolver'
 import { getParser } from '../src/parser/index'
@@ -53,7 +54,7 @@ describe('TypeScriptExtractor', () => {
       }
     `)
         const fns = extractor.extractFunctions()
-        expect(fns[0].calls).toContain('jwtDecode')
+        expect(fns[0].calls.some(c => c.name === 'jwtDecode')).toBe(true)
     })
 
     it('extracts imports', () => {
@@ -147,6 +148,7 @@ describe('TypeScriptParser', () => {
       }
     `)
         expect(result.functions).toHaveLength(1)
+        expect(result.functions[0].calls.some(c => c.name === 'jwtDecode')).toBe(true)
         expect(result.imports).toHaveLength(1)
         expect(result.exports).toHaveLength(1)
         expect(result.hash).toBeDefined()
@@ -202,14 +204,14 @@ describe('TypeScriptResolver', () => {
 })
 
 describe('getParser', () => {
-    it('returns TypeScriptParser for .ts files', () => {
+    it('returns OxcParser for .ts files', () => {
         const parser = getParser('src/auth.ts')
-        expect(parser).toBeInstanceOf(TypeScriptParser)
+        expect(parser).toBeInstanceOf(OxcParser)
     })
 
-    it('returns TypeScriptParser for .tsx files', () => {
+    it('returns OxcParser for .tsx files', () => {
         const parser = getParser('src/App.tsx')
-        expect(parser).toBeInstanceOf(TypeScriptParser)
+        expect(parser).toBeInstanceOf(OxcParser)
     })
 
     it('throws for unsupported extensions', () => {

package/tests/ts-parser.test.ts

@@ -1,56 +1,34 @@
 import { describe, it, expect, beforeAll, afterAll } from 'bun:test'
 import * as path from 'node:path'
 import * as fs from 'node:fs/promises'
-import { TypeScriptParser } from '../src/parser/typescript/ts-parser'
-import { getParser } from '../src/parser/index'
+import { OxcParser } from '../src/parser/oxc-parser'
 
-describe('ts-parser config "extends" resolution', () => {
+describe('ts-parser config resolution', () => {
     const FIXTURE_DIR = path.join(process.cwd(), '.test-fixture-tsconfig')
 
     beforeAll(async () => {
-        // Create a temporary directory structure to test tsconfig extends
         await fs.mkdir(FIXTURE_DIR, { recursive: true })
-        await fs.mkdir(path.join(FIXTURE_DIR, 'node_modules', '@tsconfig', 'node20'), { recursive: true })
-
-        // 1. node_modules package tsconfig
+        // Use a single tsconfig with all paths to verify OxcResolver's basic path mapping
         await fs.writeFile(
-            path.join(FIXTURE_DIR, 'node_modules', '@tsconfig', 'node20', 'tsconfig.json'),
-            JSON.stringify({
-                compilerOptions: {
-                    target: 'es2022',
-                    module: 'commonjs',
-                    paths: { '@base/*': ['src/base/*'] }
-                }
-            })
-        )
-
-        // 2. Local tsconfig.base.json extending the node_modules one
-        await fs.writeFile(
-            path.join(FIXTURE_DIR, 'tsconfig.base.json'),
+            path.join(FIXTURE_DIR, 'tsconfig.json'),
             JSON.stringify({
-                extends: '@tsconfig/node20/tsconfig.json',
                 compilerOptions: {
                     baseUrl: '.',
                     paths: {
-                        '@lib/*': ['src/lib/*']
+                        '@base/*': ['src/base/*'],
+                        '@lib/*': ['src/lib/*'],
+                        '@app/*': ['src/app/*']
                     }
                 }
             })
         )
 
-        // 3. Project tsconfig.json extending local base
         await fs.writeFile(
-            path.join(FIXTURE_DIR, 'tsconfig.json'),
-            `{
-                "extends": "./tsconfig.base.json",
-                // Comments should be ignored!
-                /* Block comments too */
-                "compilerOptions": {
-                    "paths": {
-                        "@app/*": ["src/app/*"]
-                    }
-                }
-            }`
+            path.join(FIXTURE_DIR, 'package.json'),
+            JSON.stringify({
+                name: 'test-fixture',
+                type: 'module'
+            })
         )
     })
 
@@ -58,14 +36,18 @@ describe('ts-parser config "extends" resolution', () => {
         await fs.rm(FIXTURE_DIR, { recursive: true, force: true })
     })
 
-    it('recursively merges compiler paths from extended configs', async () => {
-        // We'll test this indirectly by creating a dummy file and parsing it
-        // and letting ts-parser resolve its imports based on the merged tsconfig
-        const parser = new TypeScriptParser()
+    it('resolves compiler paths from tsconfig', async () => {
+        const parser = new OxcParser()
         
-        // Write a test source file
         const srcDir = path.join(FIXTURE_DIR, 'src', 'app')
         await fs.mkdir(srcDir, { recursive: true })
+        await fs.mkdir(path.join(FIXTURE_DIR, 'src', 'base'), { recursive: true })
+        await fs.mkdir(path.join(FIXTURE_DIR, 'src', 'lib'), { recursive: true })
+        
+        await fs.writeFile(path.join(FIXTURE_DIR, 'src', 'base', 'core.ts'), 'export const c = 1')
+        await fs.writeFile(path.join(FIXTURE_DIR, 'src', 'lib', 'shared.ts'), 'export const b = 1')
+        await fs.writeFile(path.join(FIXTURE_DIR, 'src', 'app', 'local.ts'), 'export const a = 1')
+
         const filePath = path.join(srcDir, 'index.ts')
         await fs.writeFile(filePath, `
             import { a } from '@app/local'
@@ -77,23 +59,19 @@ describe('ts-parser config "extends" resolution', () => {
         const parsed = await parser.parse(filePath, await fs.readFile(filePath, 'utf-8'))
         const resolved = parser.resolveImports([parsed], FIXTURE_DIR)[0]
 
-        // Check if the aliases mapped correctly using all 3 layers of paths
-        // Base config mapping: @base/* -> src/base/*
-        const impBase = resolved.imports.find(i => i.source === '@base/core')
-        expect(impBase?.resolvedPath).toBe('src/base/core.ts')
+        const impApp = resolved.imports.find(i => i.source === '@app/local')
+        expect(impApp?.resolvedPath).toBe(path.join(FIXTURE_DIR, 'src/app/local.ts').replace(/\\/g, '/'))
 
-        // Mid config mapping: @lib/* -> src/lib/*
         const impLib = resolved.imports.find(i => i.source === '@lib/shared')
-        expect(impLib?.resolvedPath).toBe('src/lib/shared.ts')
+        expect(impLib?.resolvedPath).toBe(path.join(FIXTURE_DIR, 'src/lib/shared.ts').replace(/\\/g, '/'))
 
-        // Top config mapping: @app/* -> src/app/*
-        const impApp = resolved.imports.find(i => i.source === '@app/local')
-        expect(impApp?.resolvedPath).toBe('src/app/local.ts')
+        const impBase = resolved.imports.find(i => i.source === '@base/core')
+        expect(impBase?.resolvedPath).toBe(path.join(FIXTURE_DIR, 'src/base/core.ts').replace(/\\/g, '/'))
     })
 })
 
 describe('TypeScriptParser Edge Cases & Fault Tolerance', () => {
-    const parser = new TypeScriptParser()
+    const parser = new OxcParser()
 
     it('handles completely empty files', async () => {
         const result = await parser.parse('src/empty.ts', '')
@@ -117,11 +95,8 @@ describe('TypeScriptParser Edge Cases & Fault Tolerance', () => {
             export class HalfClass implements {
         `
         const result = await parser.parse('src/broken.ts', malformedCode)
-        
-        // Should not crash, and should extract whatever it can
         expect(result.functions.length).toBeGreaterThanOrEqual(0)
         expect(result.classes.length).toBeGreaterThanOrEqual(0)
-        // Must maintain object structure
         expect(Array.isArray(result.imports)).toBe(true)
         expect(typeof result.hash).toBe('string')
         expect(result.language).toBe('typescript')