@openinc/parse-server-opendash 3.21.0 → 3.22.0

package/dist/features/documentation/core/Importer.d.ts

@@ -17,5 +17,5 @@ export declare class DocumentationImporter {
     /**
      * Get file content from GitHub
      */
-    getFileContent(owner: string, repo: string, path: string, ref?: string): Promise<any>;
+    getFileContent(path: string): Promise<any>;
 }

package/dist/features/documentation/core/Importer.js

@@ -19,13 +19,13 @@ class DocumentationImporter {
         // Validate token
         const gitUser = await this.githubClient.validateToken();
         // Get repository info
-        const repo = await this.githubClient.getRepository(options.organization, options.repository);
+        const repo = await this.githubClient.getRepository();
         // Determine branch to use
         const branch = options.branch || repo.default_branch;
         // Validate branch exists
         await this.validateBranch(options.organization, options.repository, branch);
         // Get branch info (commit SHA)
-        const branchInfo = await this.githubClient.getBranch(options.organization, options.repository, branch);
+        const branchInfo = await this.githubClient.getBranch();
         const latestCommitSha = branchInfo.commit.sha;
         // Attempt to load previously imported commit SHA from Parse
         let previousCommitSha;
@@ -59,7 +59,7 @@ class DocumentationImporter {
                 },
             };
         }
-        const treeData = await this.githubClient.getTree(options.organization, options.repository, latestCommitSha);
+        const treeData = await this.githubClient.getTree(latestCommitSha);
         // Organize structure with filtering and root path
         const structure = await Organizer_1.DocumentationOrganizer.organizeRepositoryStructure(treeData, options.fileFilter, options.rootPath, this.githubClient, options.organization, options.repository, branch, options.defaultFolderConfig);
         // Clean up old documentation that is no longer in the repository
@@ -113,7 +113,7 @@ class DocumentationImporter {
      */
     async validateBranch(owner, repo, branch) {
         try {
-            const branches = await this.githubClient.getBranches(owner, repo);
+            const branches = await this.githubClient.getBranches();
             const branchNames = branches.map((b) => b.name);
             if (!branchNames.includes(branch)) {
                 throw new Error(`Branch '${branch}' not found. Available branches: ${branchNames.join(", ")}`);
@@ -126,8 +126,8 @@ class DocumentationImporter {
     /**
      * Get file content from GitHub
      */
-    async getFileContent(owner, repo, path, ref) {
-        return this.githubClient.getFileContent(owner, repo, path, ref);
+    async getFileContent(path) {
+        return this.githubClient.getFileContent(path);
     }
 }
 exports.DocumentationImporter = DocumentationImporter;

package/dist/features/documentation/core/Organizer.js

@@ -20,7 +20,7 @@ class DocumentationOrganizer {
         // 2. Build folder structure & identify config.json files
         const { root: builtRoot, configFiles } = StructureBuilder_1.StructureBuilder.build(normalizedFiles, rootPath, defaultFolderConfig);
         // 3. Apply configs
-        await ConfigApplier_1.ConfigApplier.apply(builtRoot, configFiles, githubClient, owner, repo, branch, rootPath);
+        await ConfigApplier_1.ConfigApplier.apply(builtRoot, configFiles, githubClient, branch, rootPath);
         // 4. Apply feature filtering
         console.log(`[DocumentationOrganizer] Applying feature-based filtering...`);
         const preFilterFileCount = normalizedFiles.length;
@@ -35,9 +35,9 @@ class DocumentationOrganizer {
         }
         // 5. Enrich commit metadata
         if (githubClient && owner && repo) {
-            await MetadataEnricher_1.MetadataEnricher.enrichCommits(filteredFiles, githubClient, owner, repo, branch, rootPath);
+            await MetadataEnricher_1.MetadataEnricher.enrichCommits(filteredFiles, githubClient, rootPath);
             // 6. Load content
-            await ContentLoader_1.ContentLoader.populate(filteredFiles, githubClient, owner, repo, branch, rootPath);
+            await ContentLoader_1.ContentLoader.populate(filteredFiles, githubClient, branch, rootPath);
         }
         // Build extension map
         const filesByExtension = new Map();

package/dist/features/documentation/functions/importDocs.js

@@ -6,6 +6,7 @@ const core_1 = require("../core");
 const config_1 = require("../config");
 const Converter_1 = require("../core/Converter");
 const types_1 = require("../../../types");
+const LinkResolver_1 = require("../services/LinkResolver");
 const GITHUB_TOKEN = process.env.OI_DOCUMENTATION_GITHUB_ACCESS_TOKEN;
 async function importDocs() {
     try {
@@ -23,7 +24,9 @@ async function importDocs() {
                 .equalTo("objectId", userId)
                 .include("tenant")
                 .first({ useMasterKey: true })
-            : undefined;
+            : await new Parse.Query(Parse.User)
+                .ascending("createdAt")
+                .first({ useMasterKey: true });
         const tenantId = process.env.OI_DOCUMENTATION_TENANT_ID;
         const tenant = tenantId
             ? new types_1.Tenant({ objectId: tenantId })
@@ -31,6 +34,9 @@ async function importDocs() {
         const result = await importer.importFromRepository(config, user, tenant);
         if (result.metadata.skipped)
             return;
+        // resolve links in all files and fetch their content into
+        const linkResolver = new LinkResolver_1.LinkResolver(GITHUB_TOKEN, result.structure?.allFiles);
+        await linkResolver.resolveLinks(user, tenant);
         if (result.structure)
             await new Converter_1.DocumentationConverter(result).convert(user, tenant);
     }

package/dist/features/documentation/services/ConfigApplier.d.ts

@@ -1,7 +1,7 @@
 import { DocumentationFolder, DocumentationFile } from "../types";
 import { GitHubClient } from "./GitHubClient";
 export declare class ConfigApplier {
-    static apply(root: DocumentationFolder, configFiles: DocumentationFile[], githubClient?: GitHubClient, owner?: string, repo?: string, branch?: string, rootPath?: string): Promise<void>;
+    static apply(root: DocumentationFolder, configFiles: DocumentationFile[], githubClient?: GitHubClient, branch?: string, rootPath?: string): Promise<void>;
     /** Compare raw vs sanitized folder config and log warnings for dropped / invalid entries */
     private static diffAndWarnFolderConfig;
     private static diffAndWarnFileConfig;

package/dist/features/documentation/services/ConfigApplier.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigApplier = void 0;
 const config_1 = require("../config");
 class ConfigApplier {
-    static async apply(root, configFiles, githubClient, owner, repo, branch, rootPath) {
+    static async apply(root, configFiles, githubClient, branch, rootPath) {
         if (!configFiles.length)
             return;
         for (const cfgFile of configFiles) {
@@ -16,8 +16,8 @@ class ConfigApplier {
             if (!folder)
                 continue;
             try {
-                if (githubClient && owner && repo) {
-                    const customRaw = await this.fetchConfigFromGitHub(cfgFile, githubClient, owner, repo, branch, rootPath);
+                if (githubClient) {
+                    const customRaw = await this.fetchConfigFromGitHub(cfgFile, githubClient, branch, rootPath);
                     const custom = (0, config_1.sanitizeFolderConfig)(customRaw);
                     this.diffAndWarnFolderConfig(customRaw, custom, cfgFile.path);
                     folder.config = { ...folder.config, ...custom };
@@ -74,12 +74,12 @@ class ConfigApplier {
             console.warn(`[ConfigApplier] Invalid type for 'locations' (expected string[]) in file '${fileBase}' (${sourcePath})`);
         }
     }
-    static async fetchConfigFromGitHub(cfgFile, githubClient, owner, repo, branch, rootPath) {
+    static async fetchConfigFromGitHub(cfgFile, githubClient, branch, rootPath) {
         const normalizedRoot = rootPath?.replace(/^\/+/g, "").replace(/\/+$/g, "");
         const fullPath = normalizedRoot
             ? `${normalizedRoot}/${cfgFile.path}`
             : cfgFile.path;
-        const fileContent = await githubClient.getFileContent(owner, repo, fullPath, branch);
+        const fileContent = await githubClient.getFileContent(fullPath);
         const json = Buffer.from(fileContent.content, "base64").toString("utf-8");
         return JSON.parse(json);
     }

package/dist/features/documentation/services/ContentLoader.d.ts

@@ -2,5 +2,5 @@ import { DocumentationFile } from "../types";
 import { GitHubClient } from "./GitHubClient";
 export declare class ContentLoader {
     private static readonly TEXT_EXTENSIONS;
-    static populate(files: DocumentationFile[], githubClient: GitHubClient, owner: string, repo: string, branch?: string, rootPath?: string): Promise<void>;
+    static populate(files: DocumentationFile[], githubClient: GitHubClient, branch?: string, rootPath?: string): Promise<void>;
 }

package/dist/features/documentation/services/ContentLoader.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentLoader = void 0;
 class ContentLoader {
-    static async populate(files, githubClient, owner, repo, branch, rootPath) {
+    static async populate(files, githubClient, branch, rootPath) {
         const candidates = files.filter((f) => this.TEXT_EXTENSIONS.has(f.extension));
         if (!candidates.length)
             return;
@@ -13,7 +13,7 @@ class ContentLoader {
                 const fullPath = normalizedRoot
                     ? `${normalizedRoot}/${file.path}`
                     : file.path;
-                const ghContent = await githubClient.getFileContent(owner, repo, fullPath, branch);
+                const ghContent = await githubClient.getFileContent(fullPath);
                 if (ghContent?.content) {
                     file.content = Buffer.from(ghContent.content, "base64").toString("utf-8");
                     fetched++;

package/dist/features/documentation/services/GitHubClient.d.ts

@@ -1,11 +1,16 @@
-import { GitHubTreeResponse, GitHubBranch, GitHubRepository } from "../types";
+import { GitHubTreeResponse, GitHubBranch, GitHubRepository, ImportOptions } from "../types";
 /**
  * GitHub API Client for fetching repository data
  */
 export declare class GitHubClient {
     private readonly baseUrl;
     private readonly headers;
-    constructor(token: string);
+    private readonly importConfig;
+    private branch;
+    private repository;
+    private tree;
+    private sha;
+    constructor(token: string, importConfig?: Partial<ImportOptions>);
     /**
      * Validate the GitHub token
      */
@@ -15,29 +20,36 @@ export declare class GitHubClient {
     /**
      * Get repository information
      */
-    getRepository(owner: string, repo: string): Promise<GitHubRepository>;
+    getRepository(): Promise<GitHubRepository>;
     /**
      * Get all branches for a repository
      */
-    getBranches(owner: string, repo: string): Promise<GitHubBranch[]>;
+    getBranches(): Promise<GitHubBranch[]>;
     /**
      * Get a specific branch
      */
-    getBranch(owner: string, repo: string, branch: string): Promise<GitHubBranch>;
+    getBranch(): Promise<GitHubBranch>;
     /**
      * Get repository tree (file structure)
      */
-    getTree(owner: string, repo: string, sha: string, recursive?: boolean): Promise<GitHubTreeResponse>;
+    getTree(sha: string, recursive?: boolean): Promise<GitHubTreeResponse>;
     /**
      * Get file content
      */
-    getFileContent(owner: string, repo: string, path: string, ref?: string): Promise<any>;
+    getFileContent(path: string): Promise<any>;
     /**
      * Get the last commit information for a specific file
      */
-    getFileLastCommit(owner: string, repo: string, path: string, ref?: string): Promise<any>;
+    getFileLastCommit(path: string, ref?: string): Promise<any>;
     /**
      * Get commit information for multiple files in batch
      */
-    getMultipleFileCommits(owner: string, repo: string, paths: string[], ref?: string): Promise<Map<string, any>>;
+    getMultipleFileCommits(paths: string[]): Promise<Map<string, any>>;
+    /**
+     * Fetches the content of each linked file from GitHub.
+     * @param ref Branch or commit SHA
+     * @param paths Array of relative file paths (from repo root)
+     * @returns Map of path to file content (decoded as string if possible)
+     */
+    private fetchLinkedFiles;
 }

package/dist/features/documentation/services/GitHubClient.js

@@ -1,17 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubClient = void 0;
+const config_1 = require("../config");
 /**
  * GitHub API Client for fetching repository data
  */
 class GitHubClient {
-    constructor(token) {
+    constructor(token, importConfig = config_1.DEFAULT_IMPORT_CONFIG) {
         this.baseUrl = "https://api.github.com";
+        this.branch = null;
+        this.repository = null;
+        this.tree = null;
+        this.sha = null;
         this.headers = {
             Authorization: `Bearer ${token}`,
             Accept: "application/vnd.github.v3+json",
             "User-Agent": "OpenInc-Documentation-Importer",
         };
+        this.importConfig = importConfig;
     }
     /**
      * Validate the GitHub token
@@ -29,8 +35,9 @@ class GitHubClient {
     /**
      * Get repository information
      */
-    async getRepository(owner, repo) {
-        const response = await fetch(`${this.baseUrl}/repos/${owner}/${repo}`, {
+    async getRepository() {
+        const { organization, repository } = this.importConfig;
+        const response = await fetch(`${this.baseUrl}/repos/${organization}/${repository}`, {
             headers: this.headers,
         });
         if (!response.ok) {
@@ -42,8 +49,9 @@ class GitHubClient {
     /**
      * Get all branches for a repository
      */
-    async getBranches(owner, repo) {
-        const response = await fetch(`${this.baseUrl}/repos/${owner}/${repo}/branches`, {
+    async getBranches() {
+        const { organization, repository } = this.importConfig;
+        const response = await fetch(`${this.baseUrl}/repos/${organization}/${repository}/branches`, {
             headers: this.headers,
         });
         if (!response.ok) {
@@ -54,8 +62,9 @@ class GitHubClient {
     /**
      * Get a specific branch
      */
-    async getBranch(owner, repo, branch) {
-        const response = await fetch(`${this.baseUrl}/repos/${owner}/${repo}/branches/${branch}`, {
+    async getBranch() {
+        const { organization, repository, branch } = this.importConfig;
+        const response = await fetch(`${this.baseUrl}/repos/${organization}/${repository}/branches/${branch}`, {
             headers: this.headers,
         });
         if (!response.ok) {
@@ -67,8 +76,9 @@ class GitHubClient {
     /**
      * Get repository tree (file structure)
      */
-    async getTree(owner, repo, sha, recursive = true) {
-        const url = `${this.baseUrl}/repos/${owner}/${repo}/git/trees/${sha}${recursive ? "?recursive=1" : ""}`;
+    async getTree(sha, recursive = true) {
+        const { organization, repository } = this.importConfig;
+        const url = `${this.baseUrl}/repos/${organization}/${repository}/git/trees/${sha}${recursive ? "?recursive=1" : ""}`;
         const response = await fetch(url, {
             headers: this.headers,
         });
@@ -80,8 +90,9 @@ class GitHubClient {
     /**
      * Get file content
      */
-    async getFileContent(owner, repo, path, ref) {
-        const url = `${this.baseUrl}/repos/${owner}/${repo}/contents/${path}${ref ? `?ref=${ref}` : ""}`;
+    async getFileContent(path) {
+        const { organization, repository, branch } = this.importConfig;
+        const url = `${this.baseUrl}/repos/${organization}/${repository}/contents/${path}${`?ref=${branch}`}`;
         const response = await fetch(url, {
             headers: this.headers,
         });
@@ -93,8 +104,9 @@ class GitHubClient {
     /**
      * Get the last commit information for a specific file
      */
-    async getFileLastCommit(owner, repo, path, ref) {
-        const url = `${this.baseUrl}/repos/${owner}/${repo}/commits?path=${encodeURIComponent(path)}&per_page=1${ref ? `&sha=${ref}` : ""}`;
+    async getFileLastCommit(path, ref) {
+        const { organization, repository } = this.importConfig;
+        const url = `${this.baseUrl}/repos/${organization}/${repository}/commits?path=${encodeURIComponent(path)}&per_page=1${ref ? `&sha=${ref}` : ""}`;
         const response = await fetch(url, {
             headers: this.headers,
         });
@@ -107,7 +119,7 @@ class GitHubClient {
     /**
      * Get commit information for multiple files in batch
      */
-    async getMultipleFileCommits(owner, repo, paths, ref) {
+    async getMultipleFileCommits(paths) {
         const commitMap = new Map();
         // Process files in batches to avoid rate limiting
         const batchSize = 5;
@@ -115,7 +127,7 @@ class GitHubClient {
             const batch = paths.slice(i, i + batchSize);
             const promises = batch.map(async (path) => {
                 try {
-                    const commit = await this.getFileLastCommit(owner, repo, path, ref);
+                    const commit = await this.getFileLastCommit(path);
                     return { path, commit };
                 }
                 catch (error) {
@@ -136,5 +148,41 @@ class GitHubClient {
         }
         return commitMap;
     }
+    /**
+     * Fetches the content of each linked file from GitHub.
+     * @param ref Branch or commit SHA
+     * @param paths Array of relative file paths (from repo root)
+     * @returns Map of path to file content (decoded as string if possible)
+     */
+    async fetchLinkedFiles(ref, paths) {
+        const result = new Map();
+        for (const path of paths) {
+            try {
+                const file = await this.getFileContent(path);
+                // GitHub returns content as base64 for binary/text files
+                if (file && file.content && file.encoding === "base64") {
+                    const buffer = Buffer.from(file.content, "base64");
+                    // Try to decode as UTF-8 string, fallback to Buffer for binary
+                    const asString = buffer.toString("utf8");
+                    // Heuristic: treat as string if no replacement chars
+                    if (!asString.includes("\uFFFD")) {
+                        result.set(path, asString);
+                    }
+                    else {
+                        result.set(path, buffer);
+                    }
+                }
+                else {
+                    // For raw text files, just use the content
+                    result.set(path, file.content ?? "");
+                }
+            }
+            catch (err) {
+                console.warn(`⚠️ Could not fetch ${path}:`, err);
+                result.set(path, "");
+            }
+        }
+        return result;
+    }
 }
 exports.GitHubClient = GitHubClient;

package/dist/features/documentation/services/LinkResolver.d.ts

@@ -0,0 +1,10 @@
+import { _User, Tenant } from "../../../types";
+import { DocumentationFile } from "../types";
+export declare class LinkResolver {
+    private gitHubClient;
+    private files;
+    constructor(gitHubToken: string, files?: DocumentationFile[]);
+    resolveLinks(user?: _User, tenant?: Tenant): Promise<void>;
+    private scanLinksWithPositions;
+    private replaceLinksInContent;
+}

package/dist/features/documentation/services/LinkResolver.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkResolver = void 0;
+const types_1 = require("../../../types");
+const GitHubClient_1 = require("./GitHubClient");
+const path_1 = __importDefault(require("path"));
+class LinkResolver {
+    constructor(gitHubToken, files = []) {
+        this.files = [];
+        this.gitHubClient = new GitHubClient_1.GitHubClient(gitHubToken);
+        this.files = files;
+    }
+    // Returns a map of unique local file/image links to their GitHub content
+    async resolveLinks(user, tenant) {
+        console.log("[LinkResolver] Resolving links in documentation files...");
+        const linkMap = this.scanLinksWithPositions();
+        // first we build an array with unique absoluteLinks.
+        const uniqueAbsoluteLinks = Array.from(new Set(Array.from(linkMap.values()).flatMap((occs) => occs.map((o) => o.absoluteLink))));
+        console.log(`[LinkResolver] Found ${uniqueAbsoluteLinks.length} unique local links to resolve.`);
+        // we can now fetch all files for absoluteLinks
+        const fetchedFiles = new Map();
+        await Promise.all(uniqueAbsoluteLinks.map(async (filePath) => {
+            try {
+                const file = await this.gitHubClient.getFileContent(filePath);
+                if (file && file.content && file.encoding === "base64") {
+                    const buffer = Buffer.from(file.content, "base64");
+                    // Try to decode as UTF-8 string, fallback to Buffer for binary
+                    const asString = buffer.toString("utf8");
+                    if (!asString.includes("\uFFFD")) {
+                        fetchedFiles.set(filePath, asString);
+                    }
+                    else {
+                        fetchedFiles.set(filePath, buffer);
+                    }
+                }
+                else {
+                    fetchedFiles.set(filePath, file.content ?? "");
+                }
+            }
+            catch (err) {
+                console.warn(`[LinkResolver] ⚠️ Could not fetch ${filePath}:`, err);
+                fetchedFiles.set(filePath, "");
+            }
+        }));
+        // old absoluteLink => new file link
+        const newLinkMap = new Map();
+        // now we can build a map of absoluteLink => new Asset URL
+        for (const [absoluteLink, content] of fetchedFiles) {
+            const fileName = absoluteLink.split("/").pop();
+            // map the data to a Parse File and save as Asset
+            const data = typeof content === "string"
+                ? { base64: Buffer.from(content, "utf8").toString("base64") }
+                : { base64: content.toString("base64") };
+            const parseFile = await new Parse.File(fileName || "file", data).save({
+                useMasterKey: true,
+            });
+            const asset = new types_1.Assets({
+                file: parseFile,
+                context: "documentation",
+                tenant,
+                user,
+                description: fileName,
+            });
+            const savedAsset = await asset.save(null, { useMasterKey: true });
+            const newURL = savedAsset.file?.url() || "";
+            newLinkMap.set(absoluteLink, newURL);
+        }
+        console.log(`[LinkResolver] Resolved and uploaded ${newLinkMap.size} linked assets.`);
+        // Finally, replace links in each file's content
+        for (const file of this.files) {
+            const occurrences = linkMap.get(file.path);
+            if (occurrences && occurrences.length) {
+                file.content = this.replaceLinksInContent(occurrences, file.content ?? "", newLinkMap);
+            }
+        }
+        console.log("[LinkResolver] Link resolution completed.");
+    }
+    // Scan all files and return a map: filePath -> array of link occurrences
+    scanLinksWithPositions() {
+        const regex = /(!?\[[^\]]*\]\(([^)]+)\))/g;
+        const result = new Map();
+        for (const file of this.files) {
+            const occurrences = [];
+            const content = file.content || "";
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                const markdown = match[1];
+                const link = match[2].trim();
+                // Skip URLs
+                if (/^https?:\/\//i.test(link) || /^mailto:/i.test(link))
+                    continue;
+                const baseDir = path_1.default.posix.dirname(file.path);
+                const absoluteLink = path_1.default.posix.normalize(path_1.default.posix.join("./docs", baseDir, link));
+                occurrences.push({
+                    filePath: file.path,
+                    link,
+                    absoluteLink,
+                    start: match.index,
+                    end: match.index + markdown.length,
+                    markdown,
+                });
+            }
+            if (occurrences.length)
+                result.set(file.path, occurrences);
+        }
+        return result;
+    }
+    // Replace links in content with new links using positions
+    replaceLinksInContent(occurrences, content, assetLinkMap) {
+        let offset = 0; // track content length changes
+        let newContent = content;
+        for (const occ of occurrences) {
+            const newLink = assetLinkMap.get(occ.absoluteLink);
+            if (!newLink)
+                continue;
+            // Replace only the link part inside markdown
+            const before = newContent.slice(0, occ.start + offset);
+            const matchText = newContent.slice(occ.start + offset, occ.end + offset);
+            const after = newContent.slice(occ.end + offset);
+            // Replace link inside [text](link)
+            const replaced = matchText.replace(occ.link, newLink);
+            newContent = before + replaced + after;
+            offset += replaced.length - matchText.length;
+        }
+        return newContent;
+    }
+}
+exports.LinkResolver = LinkResolver;

package/dist/features/documentation/services/MetadataEnricher.d.ts

@@ -1,5 +1,5 @@
 import { DocumentationFile } from "../types";
 import { GitHubClient } from "./GitHubClient";
 export declare class MetadataEnricher {
-    static enrichCommits(files: DocumentationFile[], githubClient: GitHubClient, owner: string, repo: string, branch?: string, rootPath?: string): Promise<void>;
+    static enrichCommits(files: DocumentationFile[], githubClient: GitHubClient, rootPath?: string): Promise<void>;
 }

package/dist/features/documentation/services/MetadataEnricher.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataEnricher = void 0;
 class MetadataEnricher {
-    static async enrichCommits(files, githubClient, owner, repo, branch, rootPath) {
+    static async enrichCommits(files, githubClient, rootPath) {
         const normalizedRoot = rootPath?.replace(/^\/+/g, "").replace(/\/+$/g, "");
         const fullPaths = files.map((f) => normalizedRoot ? `${normalizedRoot}/${f.path}` : f.path);
         try {
-            const commitMap = await githubClient.getMultipleFileCommits(owner, repo, fullPaths, branch);
+            const commitMap = await githubClient.getMultipleFileCommits(fullPaths);
             let enriched = 0;
             files.forEach((file, idx) => {
                 const commit = commitMap.get(fullPaths[idx]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openinc/parse-server-opendash",
-  "version": "3.21.0",
+  "version": "3.22.0",
   "description": "Parse Server Cloud Code for open.INC Stack.",
   "packageManager": "pnpm@10.15.0",
   "keywords": [