@archora/core 1.1.0

package/src/analyzer/__tests__/resolve.test.ts

@@ -0,0 +1,294 @@
+import { describe, it, expect } from 'vitest';
+import { createNodeFsFileSource } from '../sources/nodeFsFileSource';
+import { createInMemoryFileSource } from '../sources/inMemoryFileSource';
+import { createResolver, parseTsconfigPaths, parseViteAliases } from '../resolve';
+import { loadAliases } from '../loadAliases';
+import { fixturePath } from './_paths';
+import type { ProjectRef } from '../types';
+
+describe('resolve', () => {
+  it('parses tsconfig paths', () => {
+    const aliases = parseTsconfigPaths(
+      JSON.stringify({ compilerOptions: { baseUrl: '.', paths: { '@/*': ['src/*'] } } }),
+    );
+    expect(aliases).toEqual([{ prefix: '@', targets: ['src'] }]);
+  });
+
+  it('resolves @/ alias to src/*.ts and *.vue', async () => {
+    const src = await createNodeFsFileSource({ rootPath: fixturePath('sample-vue-app') });
+    const r = createResolver(src, { aliases: parseTsconfigPaths(await src.read('tsconfig.json')) });
+    expect(await r.resolve('@/utils/date', 'src/main.ts')).toBe('src/utils/date.ts');
+    expect(await r.resolve('@/components/UserCard.vue', 'src/pages/Home.vue')).toBe(
+      'src/components/UserCard.vue',
+    );
+    expect(await r.resolve('@/router', 'src/main.ts')).toBe('src/router/index.ts');
+  });
+
+  it('resolves jsconfig paths', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'jsconfig.json': JSON.stringify({
+        compilerOptions: { baseUrl: '.', paths: { '@/*': ['src/*'] } },
+      }),
+      'src/main.js': "import util from '@/lib/util';",
+      'src/lib/util.js': 'export default 1;',
+    });
+    const project: ProjectRef = {
+      id: 'p',
+      name: 'p',
+      rootPath: '/p',
+      detectedFramework: 'unknown',
+      tsconfigPath: 'jsconfig.json',
+    };
+    const r = createResolver(src, { aliases: await loadAliases(src, project) });
+    expect(await r.resolve('@/lib/util', 'src/main.js')).toBe('src/lib/util.js');
+  });
+
+  it('resolves relative imports', async () => {
+    const src = await createNodeFsFileSource({ rootPath: fixturePath('sample-cycles') });
+    const r = createResolver(src, { aliases: [] });
+    expect(await r.resolve('./b', 'src/a.ts')).toBe('src/b.ts');
+  });
+
+  // real-world: `import { card } from '..'` from src/modules/card/buttons/x.ts
+  // should land on src/modules/card/index.ts. previously misclassified as
+  // a bare specifier and routed through alias resolution (returning null).
+  it('resolves "." and ".." to the parent folder index', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'src/modules/card/index.ts': 'export const card = 1;',
+      'src/modules/card/buttons/cancel.ts': "import { card } from '..';",
+      'src/modules/card/buttons/index.ts': 'export {};',
+      'src/modules/card/buttons/sibling.ts': "import './';",
+    });
+    const r = createResolver(src, { aliases: [] });
+    expect(await r.resolve('..', 'src/modules/card/buttons/cancel.ts')).toBe(
+      'src/modules/card/index.ts',
+    );
+    expect(await r.resolve('./', 'src/modules/card/buttons/sibling.ts')).toBe(
+      'src/modules/card/buttons/index.ts',
+    );
+    expect(await r.resolve('.', 'src/modules/card/buttons/sibling.ts')).toBe(
+      'src/modules/card/buttons/index.ts',
+    );
+  });
+
+  it('resolves index.mjs and index.cjs folder imports', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'src/esm/index.mjs': 'export const x = 1;',
+      'src/cjs/index.cjs': 'exports.y = 1;',
+      'src/main.ts': "import './esm'; import './cjs';",
+    });
+    const r = createResolver(src, { aliases: [] });
+    expect(await r.resolve('./esm', 'src/main.ts')).toBe('src/esm/index.mjs');
+    expect(await r.resolve('./cjs', 'src/main.ts')).toBe('src/cjs/index.cjs');
+  });
+
+  it('loads SvelteKit and Nuxt default aliases', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'src/lib/api.ts': 'export const api = 1;',
+      'components/Card.vue': '<template />',
+    });
+    const svelteProject: ProjectRef = {
+      id: 'p',
+      name: 'p',
+      rootPath: '/p',
+      detectedFramework: 'svelte',
+    };
+    const nuxtProject: ProjectRef = {
+      id: 'p',
+      name: 'p',
+      rootPath: '/p',
+      detectedFramework: 'nuxt',
+    };
+    const svelte = createResolver(src, { aliases: await loadAliases(src, svelteProject) });
+    const nuxt = createResolver(src, { aliases: await loadAliases(src, nuxtProject) });
+    expect(await svelte.resolve('$lib/api', 'src/routes/+page.svelte')).toBe('src/lib/api.ts');
+    expect(await nuxt.resolve('~/components/Card.vue', 'app.vue')).toBe('components/Card.vue');
+    expect(await nuxt.resolve('@/components/Card.vue', 'app.vue')).toBe('components/Card.vue');
+  });
+
+  it('loads workspace package aliases from nested package.json files', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'packages/ui/package.json': JSON.stringify({ name: '@acme/ui' }),
+      'packages/ui/src/index.ts': 'export const Button = 1;',
+      'packages/ui/src/theme.ts': 'export const theme = 1;',
+      'src/main.ts': "import { Button } from '@acme/ui'; import { theme } from '@acme/ui/theme';",
+    });
+    const project: ProjectRef = {
+      id: 'p',
+      name: 'p',
+      rootPath: '/p',
+      detectedFramework: 'unknown',
+    };
+    const r = createResolver(src, { aliases: await loadAliases(src, project) });
+    expect(await r.resolve('@acme/ui', 'src/main.ts')).toBe('packages/ui/src/index.ts');
+    expect(await r.resolve('@acme/ui/theme', 'src/main.ts')).toBe('packages/ui/src/theme.ts');
+  });
+
+  it('resolves workspace package exports and blocks private subpaths when exports exist', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'packages/ui/package.json': JSON.stringify({
+        name: '@acme/ui',
+        exports: {
+          '.': { import: './src/index.ts', default: './src/index.ts' },
+          './theme': './src/theme.ts',
+        },
+      }),
+      'packages/ui/src/index.ts': 'export const Button = 1;',
+      'packages/ui/src/theme.ts': 'export const theme = 1;',
+      'packages/ui/src/private.ts': 'export const privateApi = 1;',
+      'src/main.ts': '',
+    });
+    const project: ProjectRef = {
+      id: 'p',
+      name: 'p',
+      rootPath: '/p',
+      detectedFramework: 'unknown',
+    };
+    const r = createResolver(src, { aliases: await loadAliases(src, project) });
+    expect(await r.resolve('@acme/ui', 'src/main.ts')).toBe('packages/ui/src/index.ts');
+    expect(await r.resolve('@acme/ui/theme', 'src/main.ts')).toBe('packages/ui/src/theme.ts');
+    expect(await r.resolve('@acme/ui/private', 'src/main.ts')).toBeNull();
+  });
+
+  it('falls through conditional exports when the first condition target is not a source file', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'packages/ui/package.json': JSON.stringify({
+        name: '@acme/ui',
+        exports: {
+          '.': {
+            types: './dist/index.d.ts',
+            import: './src/index.ts',
+            default: './src/fallback.ts',
+          },
+        },
+      }),
+      'packages/ui/src/index.ts': 'export const Button = 1;',
+      'packages/ui/src/fallback.ts': 'export const fallback = 1;',
+      'src/main.ts': '',
+    });
+    const project: ProjectRef = {
+      id: 'p',
+      name: 'p',
+      rootPath: '/p',
+      detectedFramework: 'unknown',
+    };
+    const r = createResolver(src, { aliases: await loadAliases(src, project) });
+    expect(await r.resolve('@acme/ui', 'src/main.ts')).toBe('packages/ui/src/index.ts');
+  });
+
+  it('resolves package root conditional exports without subpath keys', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'packages/ui/package.json': JSON.stringify({
+        name: '@acme/ui',
+        exports: {
+          import: './src/index.ts',
+          default: './src/fallback.ts',
+        },
+      }),
+      'packages/ui/src/index.ts': 'export const Button = 1;',
+      'packages/ui/src/fallback.ts': 'export const fallback = 1;',
+      'src/main.ts': '',
+    });
+    const project: ProjectRef = {
+      id: 'p',
+      name: 'p',
+      rootPath: '/p',
+      detectedFramework: 'unknown',
+    };
+    const r = createResolver(src, { aliases: await loadAliases(src, project) });
+    expect(await r.resolve('@acme/ui', 'src/main.ts')).toBe('packages/ui/src/index.ts');
+    expect(await r.resolve('@acme/ui/private', 'src/main.ts')).toBeNull();
+  });
+
+  it('resolves package imports from root package.json', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'package.json': JSON.stringify({
+        imports: {
+          '#internal': { import: './src/internal.ts', default: './src/internal.ts' },
+        },
+      }),
+      'src/internal.ts': 'export const internal = 1;',
+      'src/main.ts': '',
+    });
+    const project: ProjectRef = {
+      id: 'p',
+      name: 'p',
+      rootPath: '/p',
+      detectedFramework: 'unknown',
+    };
+    const r = createResolver(src, { aliases: await loadAliases(src, project) });
+    expect(await r.resolve('#internal', 'src/main.ts')).toBe('src/internal.ts');
+  });
+
+  it('resolves workspace package exports and imports wildcard entries', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'package.json': JSON.stringify({
+        imports: {
+          '#domain/*': './src/domain/*.ts',
+        },
+      }),
+      'packages/ui/package.json': JSON.stringify({
+        name: '@acme/ui',
+        exports: {
+          '.': './src/index.ts',
+          './components/*': './src/components/*.vue',
+        },
+      }),
+      'packages/ui/src/index.ts': 'export const ui = 1;',
+      'packages/ui/src/components/Button.vue': '<template />',
+      'packages/ui/src/private/Button.vue': '<template />',
+      'src/domain/order.ts': 'export const order = 1;',
+      'src/main.ts': '',
+    });
+    const project: ProjectRef = {
+      id: 'p',
+      name: 'p',
+      rootPath: '/p',
+      detectedFramework: 'unknown',
+    };
+    const r = createResolver(src, { aliases: await loadAliases(src, project) });
+    expect(await r.resolve('@acme/ui/components/Button', 'src/main.ts')).toBe(
+      'packages/ui/src/components/Button.vue',
+    );
+    expect(await r.resolve('@acme/ui/private/Button', 'src/main.ts')).toBeNull();
+    expect(await r.resolve('#domain/order', 'src/main.ts')).toBe('src/domain/order.ts');
+  });
+
+  it('parses vite alias object form with path.resolve', () => {
+    const aliases = parseViteAliases(`
+      import { defineConfig } from 'vite';
+      import path from 'node:path';
+      export default defineConfig({
+        resolve: {
+          alias: {
+            '@': path.resolve(__dirname, 'src'),
+            '~ui': '/packages/ui/src',
+          },
+        },
+      });
+    `);
+    const map = Object.fromEntries(aliases.map((a) => [a.prefix, a.targets]));
+    expect(map['@']).toEqual(['src']);
+    expect(map['~ui']).toEqual(['/packages/ui/src']);
+  });
+
+  it('parses vite alias array form with fileURLToPath', () => {
+    const aliases = parseViteAliases(`
+      import { fileURLToPath, URL } from 'node:url';
+      export default {
+        resolve: {
+          alias: [
+            { find: '@', replacement: fileURLToPath(new URL('./src', import.meta.url)) },
+          ],
+        },
+      };
+    `);
+    expect(aliases).toEqual([{ prefix: '@', targets: ['src'] }]);
+  });
+
+  it('returns null for unresolved bare imports', async () => {
+    const src = await createNodeFsFileSource({ rootPath: fixturePath('sample-vue-app') });
+    const r = createResolver(src, { aliases: [] });
+    expect(await r.resolve('nonexistent-pkg', 'src/main.ts')).toBeNull();
+  });
+});

package/src/analyzer/__tests__/rsc.test.ts

@@ -0,0 +1,130 @@
+// RSC / server-client boundary detection.
+
+import { describe, expect, it } from 'vitest';
+
+import { classifyModuleRuntime, detectRscLeaks } from '../rsc';
+import { analyze } from '../index';
+import { createInMemoryFileSource } from '../sources/inMemoryFileSource';
+import type { DependencyEdge, ModuleNode } from '../types';
+
+function mod(id: string, runtime: ModuleNode['runtime'] = 'shared'): ModuleNode {
+  return {
+    id,
+    absPath: id,
+    kind: 'unknown',
+    language: 'ts',
+    loc: 10,
+    exports: [],
+    isInfra: false,
+    runtime,
+  };
+}
+
+function edge(from: string, to: string, kind: DependencyEdge['kind'] = 'static'): DependencyEdge {
+  return { from, to, kind, specifier: to, resolved: true };
+}
+
+describe('classifyModuleRuntime', () => {
+  it('directive prologue beats path conventions', () => {
+    expect(
+      classifyModuleRuntime({
+        relPath: 'app/components/Form.tsx',
+        framework: 'next',
+        directives: ['use client'],
+      }),
+    ).toBe('client');
+
+    expect(
+      classifyModuleRuntime({
+        relPath: 'lib/util.ts',
+        framework: 'unknown',
+        directives: ['use server'],
+      }),
+    ).toBe('server');
+  });
+
+  it('Next App Router defaults to server, pages/api server-only', () => {
+    expect(classifyModuleRuntime({ relPath: 'app/page.tsx', framework: 'next' })).toBe('server');
+    expect(classifyModuleRuntime({ relPath: 'pages/api/hello.ts', framework: 'next' })).toBe(
+      'server',
+    );
+    expect(classifyModuleRuntime({ relPath: 'lib/util.ts', framework: 'next' })).toBe('shared');
+  });
+
+  it('Nuxt server/ folder is server', () => {
+    expect(classifyModuleRuntime({ relPath: 'server/api/hello.ts', framework: 'nuxt' })).toBe(
+      'server',
+    );
+    expect(classifyModuleRuntime({ relPath: 'pages/index.vue', framework: 'nuxt' })).toBe('shared');
+  });
+
+  it('SvelteKit conventions: +server.ts, *.server.ts, +page.svelte', () => {
+    expect(
+      classifyModuleRuntime({ relPath: 'src/routes/api/+server.ts', framework: 'svelte' }),
+    ).toBe('server');
+    expect(
+      classifyModuleRuntime({
+        relPath: 'src/routes/dashboard/+page.server.ts',
+        framework: 'svelte',
+      }),
+    ).toBe('server');
+    expect(classifyModuleRuntime({ relPath: 'src/routes/+page.svelte', framework: 'svelte' })).toBe(
+      'client',
+    );
+    expect(classifyModuleRuntime({ relPath: 'src/routes/+page.ts', framework: 'svelte' })).toBe(
+      'shared',
+    );
+  });
+});
+
+describe('detectRscLeaks', () => {
+  it('flags client -> server but allows server -> client (RSC composition is legal)', () => {
+    const modules = [
+      mod('app/page.tsx', 'server'),
+      mod('app/Form.tsx', 'client'),
+      mod('lib/db.ts', 'server'),
+      mod('components/Button.tsx', 'client'),
+    ];
+    const edges = [
+      edge('app/Form.tsx', 'lib/db.ts'), // leak
+      edge('app/page.tsx', 'components/Button.tsx'), // legal: server renders client
+      edge('app/page.tsx', 'lib/db.ts'), // legal: server -> server
+    ];
+
+    const leaks = detectRscLeaks({ modules, edges });
+    expect(leaks).toHaveLength(1);
+    expect(leaks[0]?.kind).toBe('rsc-leak');
+    expect(leaks[0]?.edge?.from).toBe('app/Form.tsx');
+    expect(leaks[0]?.edge?.to).toBe('lib/db.ts');
+  });
+
+  it('does not flag type-only edges or shared modules', () => {
+    const modules = [mod('a.ts', 'client'), mod('b.ts', 'server'), mod('shared.ts', 'shared')];
+    const edges = [
+      edge('a.ts', 'b.ts', 'type-only'),
+      edge('a.ts', 'shared.ts'),
+      edge('b.ts', 'shared.ts'),
+    ];
+    expect(detectRscLeaks({ modules, edges })).toHaveLength(0);
+  });
+});
+
+describe('rsc-leak end-to-end', () => {
+  it('surfaces client->server import as a contract violation in analyze()', async () => {
+    const fs = createInMemoryFileSource('/repo', {
+      'package.json': JSON.stringify({ name: 'x' }),
+      'app/page.tsx':
+        "import { db } from '../lib/db';\nexport default function P(){ return db; }\n",
+      'app/Form.tsx':
+        "'use client';\nimport { db } from '../lib/db';\nexport default function F(){ return db; }\n",
+      'lib/db.ts': "'use server';\nexport const db = 1;\n",
+    });
+
+    const scan = await analyze(fs);
+    const leaks = scan.contractViolations.filter((v) => v.kind === 'rsc-leak');
+    expect(leaks.length).toBeGreaterThan(0);
+    expect(leaks.some((l) => l.edge?.from === 'app/Form.tsx' && l.edge?.to === 'lib/db.ts')).toBe(
+      true,
+    );
+  });
+});