Load GitHub tools.json file locally

.github/workflows/deploy.yml

@@ -87,29 +87,24 @@ jobs:
                   app_id: ${{ secrets.GH_APP_ID }}
                   private_key: ${{ secrets.GH_APP_PRIVATE_KEY }}
 
-            # We want to redeploy, whenever the tools.json file changes
-            # so make sure to hash the file and use it as a tag for the Docker image
-            - name: 'Download tools.json File'
-              run: curl -sL https://github.com/analysis-tools-dev/static-analysis/raw/master/data/api/tools.json -o ./tools.json
-
-            - name: 'Generate Hash of tools.json File'
-              id: tools_json_hash
-              run: echo "tools_json_hash=$(sha256sum tools.json | cut -c1-7)" >> $GITHUB_ENV
+            # Hash the generated tools.json from the build (created by npm run build-data)
+            # to ensure we redeploy when tools data changes
+            - name: 'Generate Hash of built tools data'
+              run: |
+                  echo "tools_hash=$(sha256sum data/tools.json | cut -c1-7)" >> $GITHUB_ENV
 
-            # Also take screenshots.json into account, which is at
-            # https://github.com/analysis-tools-dev/assets/blob/master/screenshots.json
+            # Also take screenshots.json into account for cache busting
             - name: 'Download screenshots.json File'
               run: curl -sL https://github.com/analysis-tools-dev/assets/raw/master/screenshots.json -o ./screenshots.json
 
             - name: 'Generate Hash of screenshots.json File'
-              id: screenshots_json_hash
-              run: echo "screenshots_json_hash=$(sha256sum screenshots.json | cut -c1-7)" >> $GITHUB_ENV
+              run: echo "screenshots_hash=$(sha256sum screenshots.json | cut -c1-7)" >> $GITHUB_ENV
 
-            # Image hash is a combination of the hashes
+            # Image hash is a combination of commit + data hashes
             - name: 'Set IMAGE_NAME hash'
               run: |
                   short_hash=$(echo "${{ github.sha }}" | cut -c1-7)
-                  echo "IMAGE_NAME=${{ env.IMAGE_NAME }}:$short_hash-${{ env.tools_json_hash }}-${{ env.screenshots_json_hash }}" >> $GITHUB_ENV
+                  echo "IMAGE_NAME=${{ env.IMAGE_NAME }}:$short_hash-${{ env.tools_hash }}-${{ env.screenshots_hash }}" >> $GITHUB_ENV
 
             - name: 'Build Docker Image'
               env:

.gitignore

@@ -46,5 +46,12 @@ algolia-index.js
 
 credentials.json
 
+# Generated data files (created by npm run build-data)
+/data/tools.json
+/data/tags.json
+/data/tool-stats.json
+/data/tag-stats.json
 
 .vscode
+
+TODO.md

Dockerfile

@@ -11,12 +11,10 @@ ARG PROJECT_ID
 
 COPY . /src
 
-# Download tools.json directly in Dockerfile and detect changes
-# This is done to ensure that we redeploy the app whenever the tools.json changes
-ADD https://raw.githubusercontent.com/analysis-tools-dev/static-analysis/master/data/api/tools.json /src/data/api/tools.json
-
+# Build runs npm run build-data (prebuild hook) which fetches tools data
+# from GitHub repos and generates static JSON files, then runs next build
 RUN npm run build
-RUN rm /src/credentials.json /src/data/api/tools.json
+RUN rm /src/credentials.json
 
 FROM node:20
 WORKDIR /src

lib/repositories/StatsRepository.ts

@@ -0,0 +1,185 @@
+/**
+ * StatsRepository
+ *
+ * Repository class for accessing tool and tag statistics from static JSON files.
+ * Data is pre-built at build time by scripts/build-data.ts.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import type { StatsApiData, VotesApiData } from 'utils/types';
+import type { Tool, ToolsByLanguage } from '@components/tools/types';
+import { ToolsRepository } from './ToolsRepository';
+import { sortByVote } from 'utils/votes';
+
+export class StatsRepository {
+    private static instance: StatsRepository | null = null;
+    private toolStatsData: StatsApiData | null = null;
+    private tagStatsData: StatsApiData | null = null;
+
+    private readonly toolStatsPath: string;
+    private readonly tagStatsPath: string;
+
+    private constructor() {
+        const dataDir = path.join(process.cwd(), 'data');
+        this.toolStatsPath = path.join(dataDir, 'tool-stats.json');
+        this.tagStatsPath = path.join(dataDir, 'tag-stats.json');
+    }
+
+    static getInstance(): StatsRepository {
+        if (!StatsRepository.instance) {
+            StatsRepository.instance = new StatsRepository();
+        }
+        return StatsRepository.instance;
+    }
+
+    private loadToolStats(): StatsApiData {
+        if (this.toolStatsData) {
+            return this.toolStatsData;
+        }
+
+        if (!fs.existsSync(this.toolStatsPath)) {
+            console.warn(
+                'Static tool stats not found. Run `npm run build-data` first.',
+            );
+            return {};
+        }
+
+        const content = fs.readFileSync(this.toolStatsPath, 'utf-8');
+        this.toolStatsData = JSON.parse(content) as StatsApiData;
+        return this.toolStatsData;
+    }
+
+    private loadTagStats(): StatsApiData {
+        if (this.tagStatsData) {
+            return this.tagStatsData;
+        }
+
+        if (!fs.existsSync(this.tagStatsPath)) {
+            console.warn(
+                'Static tag stats not found. Run `npm run build-data` first.',
+            );
+            return {};
+        }
+
+        const content = fs.readFileSync(this.tagStatsPath, 'utf-8');
+        this.tagStatsData = JSON.parse(content) as StatsApiData;
+        return this.tagStatsData;
+    }
+
+    getToolStats(): StatsApiData {
+        return this.loadToolStats();
+    }
+
+    getTagStats(): StatsApiData {
+        return this.loadTagStats();
+    }
+
+    getToolViewCount(toolId: string): number {
+        const stats = this.loadToolStats();
+        return stats[toolId] || 0;
+    }
+
+    getTagViewCount(tag: string): number {
+        const stats = this.loadTagStats();
+        return stats[tag] || 0;
+    }
+
+    getLanguageStats(): ToolsByLanguage {
+        const tagStats = this.loadTagStats();
+
+        return Object.entries(tagStats)
+            .sort(([, a], [, b]) => b - a)
+            .reduce(
+                (result, [key, value]) => ({
+                    ...result,
+                    [key]: {
+                        views: value,
+                        formatters: [],
+                        linters: [],
+                    },
+                }),
+                {} as ToolsByLanguage,
+            );
+    }
+
+    getPopularLanguageStats(votes?: VotesApiData | null): ToolsByLanguage {
+        const toolsRepo = ToolsRepository.getInstance();
+        const tools = toolsRepo.withVotes(votes || null);
+        const languageStats = this.getLanguageStats();
+
+        for (const [toolId, tool] of Object.entries(tools)) {
+            const isSingleLanguage = tool.languages.length <= 2;
+
+            if (isSingleLanguage && tool.languages.length > 0) {
+                const language = tool.languages[0];
+
+                if (languageStats[language]) {
+                    const toolObj: Tool = {
+                        id: toolId,
+                        ...tool,
+                        votes: tool.votes || 0,
+                    } as Tool;
+
+                    if (tool.categories.includes('formatter')) {
+                        languageStats[language].formatters.push(toolObj);
+                    }
+                    if (tool.categories.includes('linter')) {
+                        languageStats[language].linters.push(toolObj);
+                    }
+
+                    languageStats[language].formatters.sort(sortByVote);
+                    languageStats[language].linters.sort(sortByVote);
+
+                    if (languageStats[language].formatters.length > 3) {
+                        languageStats[language].formatters.pop();
+                    }
+                    if (languageStats[language].linters.length > 3) {
+                        languageStats[language].linters.pop();
+                    }
+                }
+            }
+        }
+
+        // Filter out languages with no tools
+        for (const language of Object.keys(languageStats)) {
+            if (
+                languageStats[language].formatters.length === 0 &&
+                languageStats[language].linters.length === 0
+            ) {
+                delete languageStats[language];
+            }
+        }
+
+        return languageStats;
+    }
+
+    getMostViewedTools(votes?: VotesApiData | null): Tool[] {
+        const toolsRepo = ToolsRepository.getInstance();
+        const tools = toolsRepo.withVotes(votes || null);
+        const toolStats = this.loadToolStats();
+
+        const mostViewedToolIds = Object.keys(toolStats);
+
+        return mostViewedToolIds
+            .map((id) => {
+                const tool = tools[id];
+                if (!tool) {
+                    return null;
+                }
+
+                return {
+                    id,
+                    ...tool,
+                    votes: tool.votes || 0,
+                    views: toolStats[id],
+                } as Tool & { views: number };
+            })
+            .filter((tool): tool is Tool & { views: number } => tool !== null);
+    }
+
+    clearCache(): void {
+        this.toolStatsData = null;
+        this.tagStatsData = null;
+    }
+}