refactor: use commitFrom and commitTo in checkHiddenCOmmits

Author: fabiovincenzi

src/proxy/actions/Action.ts

@@ -14,14 +14,6 @@ export interface Commit {
   commitTS?: string; // TODO: Normalize this to commitTimestamp
   commitTimestamp?: string;
 }
-/**
- * Represents an UpdatedRef in the action.
- */
-export interface UpdatedRef {
-  ref: string;
-  oldOid: string;
-  newOid: string;
-}
 
 /**
  * Class representing a Push.
@@ -56,7 +48,6 @@ class Action {
   attestation?: string;
   lastStep?: Step;
   proxyGitPath?: string;
-  updatedRefs?: UpdatedRef[];
   newIdxFiles?: string[];
 
   /**

src/proxy/processors/push-action/checkHiddenCommits.ts

@@ -7,30 +7,29 @@ const exec = async (req: any, action: Action): Promise<Action> => {
 
   try {
     const repoPath = `${action.proxyGitPath}/${action.repoName}`;
-    console.log(`repoPath: ${repoPath}`);
 
     const introducedCommits = new Set<string>();
 
-    action.updatedRefs?.forEach(({ ref, oldOid, newOid }) => {
-      const revRange =
-        oldOid === '0000000000000000000000000000000000000000' ? newOid : `${oldOid}..${newOid}`;
-
-      const result = spawnSync('git', ['rev-list', revRange], {
-        cwd: repoPath,
-        encoding: 'utf-8',
-      });
-
-      result.stdout
-        .trim()
-        .split('\n')
-        .forEach((c) => {
-          if (c) introducedCommits.add(c);
-        });
-    });
+    // Retrieve the single ref update
+    const oldOid = action.commitFrom;
+    const newOid = action.commitTo;
+    if (!oldOid || !newOid) {
+      throw new Error('Both action.commitFrom and action.commitTo must be defined');
+    }
 
+    const revisionRange: string =
+      oldOid === '0000000000000000000000000000000000000000' ? newOid : `${oldOid}..${newOid}`;
+
+    const revListOutput = spawnSync('git', ['rev-list', revisionRange], {
+      cwd: repoPath,
+      encoding: 'utf-8',
+    }).stdout;
+    revListOutput
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .forEach((sha) => introducedCommits.add(sha));
     step.log(`Total introduced commits: ${introducedCommits.size}`);
-    step.log(`Introduced commits: ${[...introducedCommits].join(', ')}`);
-
     const packPath = path.join('.git', 'objects', 'pack');
 
     const packCommits = new Set<string>();
@@ -52,7 +51,6 @@ const exec = async (req: any, action: Action): Promise<Action> => {
     });
     step.log(`Commits nel pack: ${packCommits.size}`);
     console.log('Pack commits:', packCommits);
-    console.log('Introduced commits:', introducedCommits);
 
     const referenced: string[] = [];
     const unreferenced: string[] = [];

src/proxy/processors/push-action/parsePush.ts

@@ -26,21 +26,19 @@ async function exec(req: any, action: Action): Promise<Action> {
     if (refUpdates.length !== 1) {
       step.log('Invalid number of branch updates.');
       step.log(`Expected 1, but got ${refUpdates.length}`);
-      step.setError('Your push has been blocked. Please make sure you are pushing to a single branch.');
+      step.setError(
+        'Your push has been blocked. Please make sure you are pushing to a single branch.',
+      );
       action.addStep(step);
       return action;
     }
 
-    const cleanedUpdates = refUpdates.map((line) => {
-      const [oldOid, newOid, refWithNull] = line.split(' ');
-      const ref = refWithNull.replace(/\0.*/, '').trim();
-      return { oldOid, newOid, ref };
-    });
+    const parts = refUpdates[0].split(' ');
+    const [oldOid, newOid, rawRef] = parts;
 
-    action.updatedRefs = cleanedUpdates;
+    const branch = rawRef.replace(/\0.*/, '').trim();
 
-    const { oldOid, newOid, ref } = cleanedUpdates[0];
-    action.branch = ref;
+    action.branch = branch;
     action.setCommit(oldOid, newOid);
 
     // Check if the offset is valid and if there's data after it
@@ -66,13 +64,13 @@ async function exec(req: any, action: Action): Promise<Action> {
 
     action.commitData = getCommitData(contents as any);
     if (action.commitData.length === 0) {
-      step.log('No commit data found when parsing push.')
+      step.log('No commit data found when parsing push.');
     } else {
       if (action.commitFrom === '0000000000000000000000000000000000000000') {
         action.commitFrom = action.commitData[action.commitData.length - 1].parent;
       }
       const user = action.commitData[action.commitData.length - 1].committer;
-      action.user = user;  
+      action.user = user;
     }
 
     step.content = {
@@ -86,20 +84,24 @@ async function exec(req: any, action: Action): Promise<Action> {
     action.addStep(step);
   }
   return action;
-};
+}
 
 /**
  * Parses the name, email, and timestamp from an author or committer line.
- * 
+ *
  * Timestamp including timezone offset is required.
  * @param {string} line - The line to parse.
  * @return {Object} An object containing the name, email, and timestamp.
  */
-const parsePersonLine = (line: string): { name: string; email: string; timestamp: string } | null => {
+const parsePersonLine = (
+  line: string,
+): { name: string; email: string; timestamp: string } | null => {
   const personRegex = /^(.*?) <(.*?)> (\d+) ([+-]\d+)$/;
   const match = line.match(personRegex);
   if (!match) {
-    throw new Error(`Failed to parse person line: ${line}. Make sure to include a name, email, timestamp and timezone offset.`);
+    throw new Error(
+      `Failed to parse person line: ${line}. Make sure to include a name, email, timestamp and timezone offset.`,
+    );
   }
   return { name: match[1].trim(), email: match[2], timestamp: match[3] };
 };
@@ -173,7 +175,10 @@ const getCommitData = (contents: CommitContent[]) => {
       }
 
       const headerLines = allLines.slice(0, headerEndIndex);
-      const message = allLines.slice(headerEndIndex + 1).join('\n').trim();
+      const message = allLines
+        .slice(headerEndIndex + 1)
+        .join('\n')
+        .trim();
       console.log({ headerLines, message });
 
       const { tree, parents, authorInfo, committerInfo } = getParsedData(headerLines);
@@ -374,22 +379,16 @@ const parsePacketLines = (buffer: Buffer): [string[], number] => {
 
     // Make sure we don't read past the end of the buffer
     if (offset + length > buffer.length) {
-        throw new Error(`Invalid packet line length ${lengthHex} at offset ${offset}`);
+      throw new Error(`Invalid packet line length ${lengthHex} at offset ${offset}`);
     }
 
     const line = buffer.toString('utf8', offset + 4, offset + length);
     lines.push(line);
     offset += length; // Move offset to the start of the next line's length prefix
   }
   return [lines, offset];
-}
+};
 
 exec.displayName = 'parsePush.exec';
 
-export {
-  exec,
-  getCommitData,
-  getPackMeta,
-  parsePacketLines,
-  unpack
-};
+export { exec, getCommitData, getPackMeta, parsePacketLines, unpack };

src/proxy/processors/push-action/writePack.ts

@@ -28,7 +28,7 @@ const exec = async (req: any, action: Action) => {
 
     const newIdxFiles = [...after].filter((f) => !before.has(f));
     action.newIdxFiles = newIdxFiles;
-    step.log(`.idx generati da questo push: ${newIdxFiles.join(', ') || '(nessuno)'}`);
+    step.log(`new idx files: ${newIdxFiles}`);
 
     step.setContent(content);
   } catch (e: any) {