@atlaspack/inspector 0.0.19-canary.3998

package/src/backend/services/findSourceCodeUrl.test.ts

@@ -0,0 +1,228 @@
+import assert from 'assert';
+import * as sinon from 'sinon';
+import path from 'path';
+import fs from 'fs';
+import childProcess from 'child_process';
+import {findProjectRoot, findSourceCodeURL} from './findSourceCodeUrl';
+
+describe('findSourceCodeUrl', function () {
+  let sandbox: sinon.SinonSandbox;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('findProjectRoot', function () {
+    it('should find project root when .git directory exists', function () {
+      const mockTarget = '/path/to/project/subdir';
+      const mockResolvedPath = '/resolved/path/to/project/subdir';
+      const mockProjectRoot = '/resolved/path/to/project';
+
+      sandbox.stub(path, 'resolve').returns(mockResolvedPath);
+      sandbox.stub(path, 'dirname').returns(mockProjectRoot);
+      sandbox.stub(path, 'join').returns('/resolved/path/to/project/.git');
+      sandbox.stub(fs, 'existsSync').returns(true);
+
+      const result = findProjectRoot(mockTarget);
+
+      assert.equal(result, mockResolvedPath);
+      assert(
+        (path.resolve as sinon.SinonStub).calledWith(process.cwd(), mockTarget),
+      );
+      assert(
+        (fs.existsSync as sinon.SinonStub).calledWith(
+          '/resolved/path/to/project/.git',
+        ),
+      );
+    });
+
+    it('should return null when no .git directory is found', function () {
+      const mockTarget = '/path/to/project';
+      const mockResolvedPath = '/resolved/path/to/project';
+
+      sandbox.stub(path, 'resolve').returns(mockResolvedPath);
+      sandbox.stub(path, 'dirname').callsFake((p: string) => {
+        if (p === mockResolvedPath) return '/resolved/path/to';
+        if (p === '/resolved/path/to') return '/resolved/path';
+        if (p === '/resolved/path') return '/resolved';
+        if (p === '/resolved') return '/';
+        return '/';
+      });
+      sandbox
+        .stub(path, 'join')
+        .callsFake((p1: string, p2: string) => `${p1}/${p2}`);
+      sandbox.stub(fs, 'existsSync').returns(false);
+
+      const result = findProjectRoot(mockTarget);
+
+      assert.equal(result, null);
+    });
+
+    it('should traverse up directories until finding .git', function () {
+      const mockTarget = '/path/to/project/deep/subdir';
+      const mockResolvedPath = '/resolved/path/to/project/deep/subdir';
+
+      sandbox.stub(path, 'resolve').returns(mockResolvedPath);
+      sandbox.stub(path, 'dirname').callsFake((p: string) => {
+        if (p === mockResolvedPath) return '/resolved/path/to/project/deep';
+        if (p === '/resolved/path/to/project/deep')
+          return '/resolved/path/to/project';
+        if (p === '/resolved/path/to/project') return '/resolved/path/to';
+        return '/';
+      });
+      sandbox
+        .stub(path, 'join')
+        .callsFake((p1: string, _p2: string) => `${p1}/.git`);
+
+      const existsStub = sandbox.stub(fs, 'existsSync');
+      existsStub
+        .withArgs('/resolved/path/to/project/deep/subdir/.git')
+        .returns(false);
+      existsStub.withArgs('/resolved/path/to/project/deep/.git').returns(false);
+      existsStub.withArgs('/resolved/path/to/project/.git').returns(true);
+
+      const result = findProjectRoot(mockTarget);
+
+      assert.equal(result, '/resolved/path/to/project');
+    });
+  });
+
+  describe('findSourceCodeURL', function () {
+    it('should return null when no project root is found', function () {
+      const mockTarget = '/path/to/project';
+
+      sandbox.stub(path, 'resolve').returns('/resolved/path');
+      sandbox.stub(path, 'dirname').returns('/');
+      sandbox.stub(path, 'join').returns('/.git');
+      sandbox.stub(fs, 'existsSync').returns(false);
+
+      const result = findSourceCodeURL(mockTarget);
+
+      assert.equal(result, null);
+    });
+
+    it('should parse GitHub SSH URL correctly', function () {
+      const mockTarget = '/path/to/project';
+
+      sandbox.stub(path, 'resolve').returns('/resolved/path');
+      sandbox.stub(path, 'dirname').returns('/');
+      sandbox.stub(path, 'join').returns('/resolved/path/.git');
+      sandbox.stub(fs, 'existsSync').returns(true);
+
+      const mockGitOutput =
+        'origin\tgit@github.com:owner/repo.git (fetch)\norigin\tgit@github.com:owner/repo.git (push)';
+      sandbox
+        .stub(childProcess, 'execSync')
+        .returns(Buffer.from(mockGitOutput));
+
+      const result = findSourceCodeURL(mockTarget);
+
+      assert.deepEqual(result, {
+        type: 'github',
+        owner: 'owner',
+        repo: 'repo',
+      });
+    });
+
+    it('should parse GitHub HTTPS URL correctly', function () {
+      const mockTarget = '/path/to/project';
+
+      sandbox.stub(path, 'resolve').returns('/resolved/path');
+      sandbox.stub(path, 'dirname').returns('/');
+      sandbox.stub(path, 'join').returns('/resolved/path/.git');
+      sandbox.stub(fs, 'existsSync').returns(true);
+
+      const mockGitOutput = 'origin\thttps://github.com/owner/repo.git (fetch)';
+      sandbox
+        .stub(childProcess, 'execSync')
+        .returns(Buffer.from(mockGitOutput));
+
+      const result = findSourceCodeURL(mockTarget);
+
+      assert.deepEqual(result, {
+        type: 'github',
+        owner: 'owner',
+        repo: 'repo',
+      });
+    });
+
+    it('should parse Bitbucket SSH URL correctly', function () {
+      const mockTarget = '/path/to/project';
+
+      sandbox.stub(path, 'resolve').returns('/resolved/path');
+      sandbox.stub(path, 'dirname').returns('/');
+      sandbox.stub(path, 'join').returns('/resolved/path/.git');
+      sandbox.stub(fs, 'existsSync').returns(true);
+
+      const mockGitOutput = 'origin\tgit@bitbucket.org:owner/repo.git (fetch)';
+      sandbox
+        .stub(childProcess, 'execSync')
+        .returns(Buffer.from(mockGitOutput));
+
+      const result = findSourceCodeURL(mockTarget);
+
+      assert.deepEqual(result, {
+        type: 'bitbucket',
+        owner: 'owner',
+        repo: 'repo',
+      });
+    });
+
+    it('should return null when no valid remote is found', function () {
+      const mockTarget = '/path/to/project';
+
+      sandbox.stub(path, 'resolve').returns('/resolved/path');
+      sandbox.stub(path, 'dirname').returns('/');
+      sandbox.stub(path, 'join').returns('/resolved/path/.git');
+      sandbox.stub(fs, 'existsSync').returns(true);
+
+      const mockGitOutput = 'origin\tgit@example.com:owner/repo.git (fetch)';
+      sandbox
+        .stub(childProcess, 'execSync')
+        .returns(Buffer.from(mockGitOutput));
+
+      const result = findSourceCodeURL(mockTarget);
+
+      assert.equal(result, null);
+    });
+
+    it('should return null when git command fails', function () {
+      const mockTarget = '/path/to/project';
+
+      sandbox.stub(path, 'resolve').returns('/resolved/path');
+      sandbox.stub(path, 'dirname').returns('/');
+      sandbox.stub(path, 'join').returns('/resolved/path/.git');
+      sandbox.stub(fs, 'existsSync').returns(true);
+
+      sandbox
+        .stub(childProcess, 'execSync')
+        .throws(new Error('Git command failed'));
+
+      assert.throws(() => {
+        findSourceCodeURL(mockTarget);
+      }, Error);
+    });
+
+    it('should return null when URL format is invalid', function () {
+      const mockTarget = '/path/to/project';
+
+      sandbox.stub(path, 'resolve').returns('/resolved/path');
+      sandbox.stub(path, 'dirname').returns('/');
+      sandbox.stub(path, 'join').returns('/resolved/path/.git');
+      sandbox.stub(fs, 'existsSync').returns(true);
+
+      const mockGitOutput = 'origin\tinvalid-url-format (fetch)';
+      sandbox
+        .stub(childProcess, 'execSync')
+        .returns(Buffer.from(mockGitOutput));
+
+      const result = findSourceCodeURL(mockTarget);
+
+      assert.equal(result, null);
+    });
+  });
+});

package/src/backend/services/findSourceCodeUrl.ts

@@ -0,0 +1,146 @@
+import path from 'path';
+import fs from 'fs';
+import childProcess from 'child_process';
+
+const PROJECT_ROOT_DIRS = [
+  '.parcelrc',
+  '.atlaspackrc',
+  'yarn.lock',
+  'package-lock.json',
+  'pnpm-lock.yaml',
+];
+
+/**
+ * Finds a root directory that contains a marker directory.
+ *
+ * @param target - The target directory to search from.
+ * @param candidate - The marker directory to search for.
+ */
+export function findRoot(target: string, candidate: string): string | null {
+  let projectRoot = path.resolve(process.cwd(), target);
+  let exists = false;
+  while (projectRoot !== '/' && projectRoot !== '.') {
+    if (fs.existsSync(path.join(projectRoot, candidate))) {
+      exists = true;
+      break;
+    }
+    projectRoot = path.dirname(projectRoot);
+  }
+
+  if (!exists) {
+    return null;
+  }
+
+  return projectRoot;
+}
+
+/**
+ * Finds a root directory that contains a `.git` directory.
+ * This is not quite matching `@atlaspack/core`'s logic.
+ *
+ * @param target - The target directory to search from.
+ */
+export function findRepositoryRoot(target: string): string | null {
+  return findRoot(target, '.git');
+}
+
+/**
+ * Finds a root directory that contains a project root directory.
+ *
+ * @param target - The target directory to search from.
+ */
+export function findProjectRoot(target: string): string | null {
+  for (const candidate of PROJECT_ROOT_DIRS) {
+    const root = findRoot(target, candidate);
+    if (root) {
+      return root;
+    }
+  }
+  return null;
+}
+
+/**
+ * A parsed remote repository URL, for either GitHub or BitBucket repositories.
+ *
+ * @example
+ * ```ts
+ * // github.com/owner/repo
+ * {
+ *   owner: 'owner',
+ *   repo: 'repo',
+ *   type: 'github',
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // bitbucket.org/owner/repo
+ * {
+ *   owner: 'owner',
+ *   repo: 'repo',
+ *   type: 'bitbucket',
+ * }
+ * ```
+ */
+export interface SourceCodeURL {
+  owner: string;
+  repo: string;
+  type: 'github' | 'bitbucket';
+}
+
+/**
+ * Based on the directory path, find a source code URL for this project.
+ *
+ * This is based on parsing `git remote` URLs.
+ *
+ * Both SSH and HTTP URLs should be supported for both GitHub and BitBucket
+ * Cloud.
+ *
+ * If a repository has multiple remotes, the first GitHub/BitBucket remote
+ * will be used.
+ *
+ * This might not work for repositories using BitBucket Server, or mirror
+ * URLs as remotes.
+ */
+export function findSourceCodeURL(target: string): SourceCodeURL | null {
+  const repositoryRoot = findRepositoryRoot(target);
+  const projectRoot = findProjectRoot(target);
+
+  if (!repositoryRoot || !projectRoot) {
+    return null;
+  }
+
+  const remotes = childProcess
+    .execSync('git remote -v', {
+      cwd: repositoryRoot,
+    })
+    .toString()
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => line.split('\t'))
+    .map(([name, url]) => ({name, url}));
+
+  const remote = remotes.find(
+    ({url}) => url.includes('bitbucket.org') || url.includes('github.com'),
+  )?.url;
+
+  if (!remote) {
+    return null;
+  }
+
+  const remoteUrl = remote.split(' ')[0];
+  const type = remoteUrl.includes('bitbucket.org') ? 'bitbucket' : 'github';
+
+  // get owner and repo from HTTP or SSH urls
+  const regex =
+    /^(?:https?:\/\/|git@)(github|bitbucket)\.(com|org)[:/]([^/\s.]+)\/([^/\s.]+)(\.git)?/;
+  const match = remoteUrl.match(regex);
+
+  if (!match) {
+    return null;
+  }
+
+  const [, , , owner, repo] = match;
+
+  return {type, owner, repo};
+}

package/src/backend/services/getCacheStats.test.ts

@@ -0,0 +1,169 @@
+import assert from 'assert';
+import * as sinon from 'sinon';
+import {getCacheStats} from './getCacheStats';
+
+describe('getCacheStats', function () {
+  let sandbox: sinon.SinonSandbox;
+  let mockCache: any;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+    mockCache = {
+      keys: sandbox.stub(),
+      getBlobSync: sandbox.stub(),
+    };
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('should return empty stats for empty cache', function () {
+    mockCache.keys.returns([]);
+
+    const result = getCacheStats(mockCache);
+
+    assert.deepEqual(result, {
+      size: 0,
+      count: 0,
+      keySize: 0,
+      assetContentCount: 0,
+      assetContentSize: 0,
+      assetMapCount: 0,
+      assetMapSize: 0,
+    });
+  });
+
+  it('should calculate stats for cache with regular keys', function () {
+    const mockKeys = ['key1', 'key2', 'key3'];
+    const mockValues = [
+      Buffer.from('value1'),
+      Buffer.from('value2'),
+      Buffer.from('value3'),
+    ];
+
+    mockCache.keys.returns(mockKeys);
+    mockCache.getBlobSync.onCall(0).returns(mockValues[0]);
+    mockCache.getBlobSync.onCall(1).returns(mockValues[1]);
+    mockCache.getBlobSync.onCall(2).returns(mockValues[2]);
+
+    const result = getCacheStats(mockCache);
+
+    const expectedSize =
+      mockValues[0].length + mockValues[1].length + mockValues[2].length;
+    const expectedKeySize =
+      Buffer.from('key1').length +
+      Buffer.from('key2').length +
+      Buffer.from('key3').length;
+
+    assert.equal(result.size, expectedSize);
+    assert.equal(result.count, 3);
+    assert.equal(result.keySize, expectedKeySize);
+    assert.equal(result.assetContentCount, 0);
+    assert.equal(result.assetContentSize, 0);
+    assert.equal(result.assetMapCount, 0);
+    assert.equal(result.assetMapSize, 0);
+  });
+
+  it('should count asset content keys correctly', function () {
+    const mockKeys = ['asset1:content', 'asset2:content', 'other-key'];
+    const mockValues = [
+      Buffer.from('content1'),
+      Buffer.from('content2'),
+      Buffer.from('other'),
+    ];
+
+    mockCache.keys.returns(mockKeys);
+    mockCache.getBlobSync.onCall(0).returns(mockValues[0]);
+    mockCache.getBlobSync.onCall(1).returns(mockValues[1]);
+    mockCache.getBlobSync.onCall(2).returns(mockValues[2]);
+
+    const result = getCacheStats(mockCache);
+
+    assert.equal(result.assetContentCount, 2);
+    assert.equal(
+      result.assetContentSize,
+      mockValues[0].length + mockValues[1].length,
+    );
+  });
+
+  it('should count asset map keys correctly', function () {
+    const mockKeys = ['asset1:map', 'asset2:map', 'other-key'];
+    const mockValues = [
+      Buffer.from('map1'),
+      Buffer.from('map2'),
+      Buffer.from('other'),
+    ];
+
+    mockCache.keys.returns(mockKeys);
+    mockCache.getBlobSync.onCall(0).returns(mockValues[0]);
+    mockCache.getBlobSync.onCall(1).returns(mockValues[1]);
+    mockCache.getBlobSync.onCall(2).returns(mockValues[2]);
+
+    const result = getCacheStats(mockCache);
+
+    assert.equal(result.assetMapCount, 2);
+    assert.equal(
+      result.assetMapSize,
+      mockValues[0].length + mockValues[1].length,
+    );
+  });
+
+  it('should handle mixed cache keys correctly', function () {
+    const mockKeys = [
+      'asset1:content',
+      'asset2:map',
+      'regular-key',
+      'asset3:content',
+      'asset4:map',
+    ];
+    const mockValues = [
+      Buffer.from('content1'),
+      Buffer.from('map1'),
+      Buffer.from('regular'),
+      Buffer.from('content2'),
+      Buffer.from('map2'),
+    ];
+
+    mockCache.keys.returns(mockKeys);
+    mockValues.forEach((value, index) => {
+      mockCache.getBlobSync.onCall(index).returns(value);
+    });
+
+    const result = getCacheStats(mockCache);
+
+    const totalSize = mockValues.reduce((sum, val) => sum + val.length, 0);
+    const totalKeySize = mockKeys.reduce(
+      (sum, key) => sum + Buffer.from(key).length,
+      0,
+    );
+
+    assert.equal(result.size, totalSize);
+    assert.equal(result.count, 5);
+    assert.equal(result.keySize, totalKeySize);
+    assert.equal(result.assetContentCount, 2);
+    assert.equal(
+      result.assetContentSize,
+      mockValues[0].length + mockValues[3].length,
+    );
+    assert.equal(result.assetMapCount, 2);
+    assert.equal(
+      result.assetMapSize,
+      mockValues[1].length + mockValues[4].length,
+    );
+  });
+
+  it('should handle empty string keys', function () {
+    const mockKeys = [''];
+    const mockValues = [Buffer.from('')];
+
+    mockCache.keys.returns(mockKeys);
+    mockCache.getBlobSync.onCall(0).returns(mockValues[0]);
+
+    const result = getCacheStats(mockCache);
+
+    assert.equal(result.size, 0);
+    assert.equal(result.count, 1);
+    assert.equal(result.keySize, 0);
+  });
+});

package/src/backend/services/getCacheStats.ts

@@ -0,0 +1,46 @@
+import {LMDBLiteCache} from '@atlaspack/cache';
+
+export interface CacheStats {
+  size: number;
+  count: number;
+  keySize: number;
+  assetContentCount: number;
+  assetContentSize: number;
+  assetMapCount: number;
+  assetMapSize: number;
+}
+
+/**
+ * Aggregate data based on general cache usage, by reading all entries
+ * in the cache.
+ *
+ * This can take a non-neglible amount of time on large caches, but
+ * will still be a lot faster than the graph deserialization steps.
+ */
+export function getCacheStats(cache: LMDBLiteCache): CacheStats {
+  const stats: CacheStats = {
+    size: 0,
+    count: 0,
+    keySize: 0,
+    assetContentCount: 0,
+    assetContentSize: 0,
+    assetMapCount: 0,
+    assetMapSize: 0,
+  };
+
+  for (const key of cache.keys()) {
+    const value = cache.getBlobSync(key);
+    stats.size += value.length;
+    stats.keySize += Buffer.from(key).length;
+    stats.count++;
+    if (key.endsWith(':content')) {
+      stats.assetContentCount++;
+      stats.assetContentSize += value.length;
+    } else if (key.endsWith(':map')) {
+      stats.assetMapCount++;
+      stats.assetMapSize += value.length;
+    }
+  }
+
+  return stats;
+}

package/src/backend/services/getDisplayName.test.ts

@@ -0,0 +1,84 @@
+import assert from 'assert';
+import {getDisplayName} from './getDisplayName';
+
+describe('getDisplayName', function () {
+  it('should return display name for asset node', function () {
+    const assetNode = {
+      type: 'asset',
+      value: {
+        filePath: '/path/to/file.js',
+      },
+      id: 'asset1',
+    };
+
+    const result = getDisplayName(assetNode);
+
+    assert.equal(result, 'asset: /path/to/file.js');
+  });
+
+  it('should return display name for dependency node', function () {
+    const dependencyNode = {
+      type: 'dependency',
+      value: {
+        specifier: './module',
+      },
+      id: 'dep1',
+    };
+
+    const result = getDisplayName(dependencyNode);
+
+    assert.equal(result, "dependency: import './module'");
+  });
+
+  it('should return display name for asset_group node', function () {
+    const assetGroupNode = {
+      type: 'asset_group',
+      value: {
+        filePath: '/path/to/asset-group.js',
+      },
+      id: 'group1',
+    };
+
+    const result = getDisplayName(assetGroupNode);
+
+    assert.equal(result, 'asset group: /path/to/asset-group.js');
+  });
+
+  it('should return display name for bundle node', function () {
+    const bundleNode = {
+      type: 'bundle',
+      value: {
+        displayName: 'main.js',
+      },
+      id: 'bundle1',
+    };
+
+    const result = getDisplayName(bundleNode);
+
+    assert.equal(result, 'bundle: main.js');
+  });
+
+  it('should return node id for unknown node type', function () {
+    const unknownNode = {
+      type: 'unknown',
+      value: {},
+      id: 'unknown123',
+    };
+
+    const result = getDisplayName(unknownNode);
+
+    assert.equal(result, 'unknown123');
+  });
+
+  it('should return node id when value is null', function () {
+    const nodeWithNullValue = {
+      type: 'unknown_type',
+      value: null,
+      id: 'null-asset',
+    };
+
+    const result = getDisplayName(nodeWithNullValue);
+
+    assert.equal(result, 'null-asset');
+  });
+});

package/src/backend/services/getDisplayName.ts

@@ -0,0 +1,20 @@
+/* eslint-disable monorepo/no-internal-import */
+// @ts-expect-error TS2749
+import type {Node} from '@atlaspack/core/lib/types.js';
+
+export function getDisplayName(node: Node): string {
+  if (node.type === 'asset') {
+    return `asset: ${node.value.filePath}`;
+  }
+  if (node.type === 'dependency') {
+    return `dependency: import '${node.value.specifier}'`;
+  }
+  if (node.type === 'asset_group') {
+    return `asset group: ${node.value.filePath}`;
+  }
+  if (node.type === 'bundle') {
+    return `bundle: ${node.value.displayName}`;
+  }
+
+  return node.id;
+}