@rmdes/indiekit-endpoint-github 1.0.0

package/lib/controllers/contributions.js

@@ -0,0 +1,60 @@
+import { GitHubClient } from "../github-client.js";
+import * as utils from "../utils.js";
+
+/**
+ * Display PRs and issues created by user
+ * @type {import("express").RequestHandler}
+ */
+export const contributionsController = {
+  async get(request, response, next) {
+    try {
+      const { username, token, cacheTtl, limits } =
+        request.app.locals.application.githubConfig;
+
+      if (!username) {
+        return response.render("contributions", {
+          title: response.locals.__("github.contributions.title"),
+          error: { message: response.locals.__("github.error.noUsername") },
+        });
+      }
+
+      const client = new GitHubClient({ token, cacheTtl });
+
+      let events = [];
+      try {
+        events = await client.getUserEvents(username, 100);
+      } catch (apiError) {
+        console.error("GitHub API error:", apiError);
+        return response.render("contributions", {
+          title: response.locals.__("github.contributions.title"),
+          actions: [],
+          parent: {
+            href: request.baseUrl,
+            text: response.locals.__("github.title"),
+          },
+          error: {
+            message: apiError.message || "Failed to fetch contributions",
+          },
+        });
+      }
+
+      const contributions = utils
+        .extractContributions(events)
+        .slice(0, limits.contributions * 2);
+
+      response.render("contributions", {
+        title: response.locals.__("github.contributions.title"),
+        actions: [],
+        parent: {
+          href: request.baseUrl,
+          text: response.locals.__("github.title"),
+        },
+        contributions,
+        username,
+        mountPath: request.baseUrl,
+      });
+    } catch (error) {
+      next(error);
+    }
+  },
+};

package/lib/controllers/dashboard.js

@@ -0,0 +1,138 @@
+import { GitHubClient } from "../github-client.js";
+import * as utils from "../utils.js";
+
+/**
+ * Display GitHub activity dashboard
+ * @type {import("express").RequestHandler}
+ */
+export const dashboardController = {
+  async get(request, response, next) {
+    try {
+      console.log("[GitHub Endpoint] Dashboard controller started");
+
+      const { githubConfig } = request.app.locals.application;
+
+      if (!githubConfig) {
+        console.error("[GitHub Endpoint] ERROR: githubConfig is undefined");
+        return response.status(500).render("github", {
+          title: "GitHub",
+          actions: [],
+          error: { message: "GitHub endpoint not configured correctly" },
+        });
+      }
+
+      const { username, token, cacheTtl, limits, featuredRepos } = githubConfig;
+      console.log("[GitHub Endpoint] Config:", {
+        username,
+        hasToken: !!token,
+        cacheTtl,
+        limits,
+        featuredRepos: featuredRepos || [],
+      });
+
+      if (!username) {
+        console.log("[GitHub Endpoint] No username configured");
+        return response.render("github", {
+          title: response.locals.__("github.title"),
+          actions: [],
+          error: { message: response.locals.__("github.error.noUsername") },
+        });
+      }
+
+      const client = new GitHubClient({ token, cacheTtl });
+      console.log("[GitHub Endpoint] Using authenticated API:", !!token);
+
+      let user;
+      let events = [];
+      let starred = [];
+      let repos = [];
+
+      try {
+        console.log("[GitHub Endpoint] Fetching GitHub data for:", username);
+        [user, events, starred, repos] = await Promise.all([
+          client.getUser(username),
+          client.getUserEvents(username, 30),
+          client.getUserStarred(username, limits.stars),
+          client.getUserRepos(username, limits.repos || 10),
+        ]);
+        console.log("[GitHub Endpoint] Raw user data:", JSON.stringify(user));
+        console.log("[GitHub Endpoint] Events count:", events?.length);
+        console.log("[GitHub Endpoint] Event types:", events?.map(e => e.type));
+        console.log("[GitHub Endpoint] Starred count:", starred?.length);
+        console.log("[GitHub Endpoint] Repos count:", repos?.length);
+      } catch (apiError) {
+        console.error("[GitHub Endpoint] API error:", apiError);
+        return response.render("github", {
+          title: response.locals.__("github.title"),
+          actions: [],
+          error: { message: apiError.message || "Failed to fetch GitHub data" },
+        });
+      }
+
+      console.log("[GitHub Endpoint] Processing data...");
+      const commits = utils.extractCommits(events);
+      console.log("[GitHub Endpoint] Extracted commits:", commits?.length);
+
+      const contributions = utils.extractContributions(events);
+      console.log("[GitHub Endpoint] Extracted contributions:", contributions?.length);
+
+      const stars = utils.formatStarred(starred);
+      console.log("[GitHub Endpoint] Formatted stars:", stars?.length);
+
+      const repositories = utils.formatRepos(repos);
+      console.log("[GitHub Endpoint] Formatted repos:", repositories?.length);
+
+      // Fetch commits from featured repos
+      let featured = [];
+      if (featuredRepos && featuredRepos.length > 0) {
+        console.log("[GitHub Endpoint] Fetching featured repos:", featuredRepos);
+        const featuredPromises = featuredRepos.map(async (repoPath) => {
+          const [owner, repo] = repoPath.split("/");
+          try {
+            const [repoData, repoCommits] = await Promise.all([
+              client.getRepo(owner, repo),
+              client.getRepoCommits(owner, repo, 5),
+            ]);
+            return {
+              ...utils.formatRepos([repoData])[0],
+              commits: repoCommits.map((c) => ({
+                sha: c.sha.slice(0, 7),
+                message: utils.truncate(c.commit.message.split("\n")[0], 60),
+                url: c.html_url,
+                author: c.commit.author.name,
+                date: c.commit.author.date,
+              })),
+            };
+          } catch (error) {
+            console.error(`[GitHub Endpoint] Error fetching ${repoPath}:`, error.message);
+            return null;
+          }
+        });
+        featured = (await Promise.all(featuredPromises)).filter(Boolean);
+        console.log("[GitHub Endpoint] Featured repos loaded:", featured.length);
+      }
+
+      const starsLimit = limits.stars || 20;
+      const reposLimit = limits.repos || 10;
+
+      console.log("[GitHub Endpoint] Rendering with limits - stars:", starsLimit, "repos:", reposLimit);
+
+      response.render("github", {
+        title: response.locals.__("github.title"),
+        actions: [],
+        user,
+        commits: commits.slice(0, limits.commits || 10),
+        contributions: contributions.slice(0, limits.contributions || 5),
+        stars: stars.slice(0, starsLimit),
+        repositories: repositories.slice(0, reposLimit),
+        featured,
+        mountPath: request.baseUrl,
+      });
+      console.log("[GitHub Endpoint] Render complete");
+    } catch (error) {
+      console.error("[GitHub Endpoint] Unexpected error:", error);
+      console.error("[GitHub Endpoint] Stack:", error.stack);
+      next(error);
+    }
+  },
+};

package/lib/controllers/featured.js

@@ -0,0 +1,116 @@
+import { GitHubClient } from "../github-client.js";
+import * as utils from "../utils.js";
+
+/**
+ * Featured repos controller
+ */
+export const featuredController = {
+  /**
+   * Get featured repos HTML page
+   * @type {import("express").RequestHandler}
+   */
+  async get(request, response, next) {
+    try {
+      const { githubConfig } = request.app.locals.application;
+
+      if (!githubConfig) {
+        return response.status(500).render("github", {
+          title: "GitHub",
+          actions: [],
+          error: { message: "GitHub endpoint not configured correctly" },
+        });
+      }
+
+      const { token, cacheTtl, featuredRepos } = githubConfig;
+
+      if (!featuredRepos || featuredRepos.length === 0) {
+        return response.render("featured", {
+          title: response.locals.__("github.featured.title"),
+          actions: [],
+          featured: [],
+        });
+      }
+
+      const client = new GitHubClient({ token, cacheTtl });
+      const featured = await fetchFeaturedRepos(client, featuredRepos);
+
+      response.render("featured", {
+        title: response.locals.__("github.featured.title"),
+        actions: [],
+        featured,
+      });
+    } catch (error) {
+      console.error("[GitHub Endpoint] Featured error:", error);
+      next(error);
+    }
+  },
+
+  /**
+   * Get featured repos JSON API
+   * @type {import("express").RequestHandler}
+   */
+  async api(request, response, next) {
+    try {
+      const { githubConfig } = request.app.locals.application;
+
+      if (!githubConfig) {
+        return response.status(500).json({ error: "GitHub not configured" });
+      }
+
+      const { token, cacheTtl, featuredRepos } = githubConfig;
+
+      if (!featuredRepos || featuredRepos.length === 0) {
+        return response.json({ featured: [] });
+      }
+
+      const client = new GitHubClient({ token, cacheTtl });
+      const featured = await fetchFeaturedRepos(client, featuredRepos);
+
+      response.json({ featured });
+    } catch (error) {
+      console.error("[GitHub Endpoint] Featured API error:", error);
+      next(error);
+    }
+  },
+};
+
+/**
+ * Fetch featured repos with commits
+ * @param {GitHubClient} client
+ * @param {string[]} featuredRepos
+ * @returns {Promise<Array>}
+ */
+async function fetchFeaturedRepos(client, featuredRepos) {
+  console.log("[GitHub Endpoint] Fetching featured repos:", featuredRepos);
+
+  const featuredPromises = featuredRepos.map(async (repoPath) => {
+    const [owner, repo] = repoPath.split("/");
+    try {
+      const [repoData, repoCommits] = await Promise.all([
+        client.getRepo(owner, repo),
+        client.getRepoCommits(owner, repo, 5),
+      ]);
+      return {
+        ...utils.formatRepos([repoData])[0],
+        commits: repoCommits.map((c) => ({
+          sha: c.sha.slice(0, 7),
+          message: utils.truncate(c.commit.message.split("\n")[0], 60),
+          url: c.html_url,
+          author: c.commit.author.name,
+          date: c.commit.author.date,
+        })),
+      };
+    } catch (error) {
+      console.error(
+        `[GitHub Endpoint] Error fetching ${repoPath}:`,
+        error.message,
+      );
+      return null;
+    }
+  });
+
+  const featured = (await Promise.all(featuredPromises)).filter(Boolean);
+  console.log("[GitHub Endpoint] Featured repos loaded:", featured.length);
+
+  return featured;
+}

package/lib/controllers/stars.js

@@ -0,0 +1,84 @@
+import { GitHubClient } from "../github-client.js";
+import * as utils from "../utils.js";
+
+/**
+ * Display starred repositories
+ * @type {import("express").RequestHandler}
+ */
+export const starsController = {
+  async get(request, response, next) {
+    try {
+      const { username, token, cacheTtl, limits } =
+        request.app.locals.application.githubConfig;
+
+      if (!username) {
+        return response.render("stars", {
+          title: response.locals.__("github.stars.title"),
+          error: { message: response.locals.__("github.error.noUsername") },
+        });
+      }
+
+      const client = new GitHubClient({ token, cacheTtl });
+
+      let starred = [];
+      try {
+        starred = await client.getUserStarred(username, limits.stars * 2);
+      } catch (apiError) {
+        console.error("GitHub API error:", apiError);
+        return response.render("stars", {
+          title: response.locals.__("github.stars.title"),
+          actions: [],
+          parent: {
+            href: request.baseUrl,
+            text: response.locals.__("github.title"),
+          },
+          error: { message: apiError.message || "Failed to fetch stars" },
+        });
+      }
+
+      const stars = utils.formatStarred(starred);
+
+      response.render("stars", {
+        title: response.locals.__("github.stars.title"),
+        actions: [],
+        parent: {
+          href: request.baseUrl,
+          text: response.locals.__("github.title"),
+        },
+        stars,
+        username,
+        mountPath: request.baseUrl,
+      });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  async api(request, response, next) {
+    try {
+      const { username, token, cacheTtl, limits } =
+        request.app.locals.application.githubConfig;
+
+      if (!username) {
+        return response.status(400).json({ error: "No username configured" });
+      }
+
+      const client = new GitHubClient({ token, cacheTtl });
+
+      let starred = [];
+      try {
+        starred = await client.getUserStarred(username, limits.stars);
+      } catch (apiError) {
+        return response
+          .status(apiError.status || 500)
+          .json({ error: apiError.message });
+      }
+
+      const stars = utils.formatStarred(starred);
+
+      response.json({ stars });
+    } catch (error) {
+      next(error);
+    }
+  },
+};

package/lib/github-client.js

@@ -0,0 +1,168 @@
+import { IndiekitError } from "@indiekit/error";
+
+const BASE_URL = "https://api.github.com";
+
+export class GitHubClient {
+  /**
+   * @param {object} options - Client options
+   * @param {string} [options.token] - GitHub personal access token
+   * @param {number} [options.cacheTtl] - Cache TTL in milliseconds
+   */
+  constructor(options = {}) {
+    this.token = options.token;
+    this.cacheTtl = options.cacheTtl || 900_000;
+    this.cache = new Map();
+  }
+
+  /**
+   * Fetch from GitHub API with caching
+   * @param {string} endpoint - API endpoint
+   * @returns {Promise<object>} - Response data
+   */
+  async fetch(endpoint) {
+    const url = `${BASE_URL}${endpoint}`;
+
+    // Check cache first
+    const cached = this.cache.get(url);
+    if (cached && Date.now() - cached.timestamp < this.cacheTtl) {
+      return cached.data;
+    }
+
+    const headers = {
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+    };
+
+    if (this.token) {
+      headers.Authorization = `Bearer ${this.token}`;
+    }
+
+    const response = await fetch(url, { headers });
+
+    if (!response.ok) {
+      throw await IndiekitError.fromFetch(response);
+    }
+
+    const data = await response.json();
+
+    // Cache result
+    this.cache.set(url, { data, timestamp: Date.now() });
+
+    return data;
+  }
+
+  /**
+   * Get user's events (commits, PRs, issues, etc.)
+   * Uses authenticated endpoint if token available (includes private activity)
+   * @param {string} username - GitHub username
+   * @param {number} [limit] - Number of events to fetch
+   * @returns {Promise<Array>} - User events
+   */
+  async getUserEvents(username, limit = 30) {
+    // Use non-public endpoint when authenticated to include private repo activity
+    const endpoint = this.token
+      ? `/users/${username}/events?per_page=${limit}`
+      : `/users/${username}/events/public?per_page=${limit}`;
+    return this.fetch(endpoint);
+  }
+
+  /**
+   * Get commits for a specific repository
+   * @param {string} owner - Repository owner
+   * @param {string} repo - Repository name
+   * @param {number} [limit] - Number of commits to fetch
+   * @returns {Promise<Array>} - Repository commits
+   */
+  async getRepoCommits(owner, repo, limit = 10) {
+    return this.fetch(`/repos/${owner}/${repo}/commits?per_page=${limit}`);
+  }
+
+  /**
+   * Get user's starred repos
+   * @param {string} username - GitHub username
+   * @param {number} [limit] - Number of repos to fetch
+   * @returns {Promise<Array>} - Starred repositories
+   */
+  async getUserStarred(username, limit = 30) {
+    return this.fetch(
+      `/users/${username}/starred?per_page=${limit}&sort=created`,
+    );
+  }
+
+  /**
+   * Get user profile
+   * @param {string} username - GitHub username
+   * @returns {Promise<object>} - User profile
+   */
+  async getUser(username) {
+    return this.fetch(`/users/${username}`);
+  }
+
+  /**
+   * Get user's repositories
+   * When authenticated, uses /user/repos to include private repos
+   * @param {string} username - GitHub username
+   * @param {number} [limit] - Number of repos to fetch
+   * @param {string} [sort] - Sort by: created, updated, pushed, full_name
+   * @returns {Promise<Array>} - User repositories
+   */
+  async getUserRepos(username, limit = 30, sort = "pushed") {
+    // When authenticated, use /user/repos for private repos access
+    // Then filter by owner to get only the user's repos (not org repos)
+    if (this.token) {
+      const repos = await this.fetch(
+        `/user/repos?per_page=${limit}&sort=${sort}&direction=desc&affiliation=owner`,
+      );
+      return repos;
+    }
+    // Unauthenticated: public repos only
+    return this.fetch(
+      `/users/${username}/repos?per_page=${limit}&sort=${sort}&direction=desc`,
+    );
+  }
+
+  /**
+   * Get repo details
+   * @param {string} owner - Repository owner
+   * @param {string} repo - Repository name
+   * @returns {Promise<object>} - Repository details
+   */
+  async getRepo(owner, repo) {
+    return this.fetch(`/repos/${owner}/${repo}`);
+  }
+
+  /**
+   * Get repo events (activity from others)
+   * @param {string} owner - Repository owner
+   * @param {string} repo - Repository name
+   * @param {number} [limit] - Number of events to fetch
+   * @returns {Promise<Array>} - Repository events
+   */
+  async getRepoEvents(owner, repo, limit = 30) {
+    return this.fetch(`/repos/${owner}/${repo}/events?per_page=${limit}`);
+  }
+
+  /**
+   * Get user's PRs across all repos
+   * @param {string} username - GitHub username
+   * @param {number} [limit] - Number of PRs to fetch
+   * @returns {Promise<object>} - Search results with PRs
+   */
+  async getUserPRs(username, limit = 30) {
+    return this.fetch(
+      `/search/issues?q=author:${username}+type:pr&per_page=${limit}&sort=created`,
+    );
+  }
+
+  /**
+   * Get user's issues across all repos
+   * @param {string} username - GitHub username
+   * @param {number} [limit] - Number of issues to fetch
+   * @returns {Promise<object>} - Search results with issues
+   */
+  async getUserIssues(username, limit = 30) {
+    return this.fetch(
+      `/search/issues?q=author:${username}+type:issue&per_page=${limit}&sort=created`,
+    );
+  }
+}