refactor: cleanup

Author: Aderinom

dist/index.js

@@ -0,0 +1,19 @@
+export interface BuildCacheStrategy {
+    restore(): Promise<void>;
+    save(): Promise<void>;
+}
+export declare function buildCacheStrategy(projectDir: string, strategy: string, toolchains: string[], fallbackBranch: string): BuildCacheStrategy | undefined;
+export declare class GithubBuildCacheStrategy implements BuildCacheStrategy {
+    private cacheKey;
+    private fallbackKey;
+    private projectDir;
+    private fallbackBranch;
+    private restoredFrom;
+    constructor(projectDir: string, toolchains: string[], fallbackBranch: string);
+    restore(): Promise<void>;
+    save(): Promise<void>;
+    static restoreBuildCache(projectDir: string, cacheKey: string, fallbackKey: string): Promise<string | undefined>;
+    static saveBuildCache(projectDir: string, cacheKey: string): Promise<void>;
+    static buildCacheKey(projectDir: string, toolchains: string[], fallbackBranch: string): string;
+    static buildFallbackCacheKey(projectDir: string, toolchains: string[], fallbackBranch: string): string;
+}

dist/src/build-cache.d.ts

@@ -1,4 +1,4 @@
-export declare function restoreFromCache(cachePath: string[], key: string, restoreKeys?: string[]): Promise<boolean>;
+export declare function restoreFromCache(cachePath: string[], key: string, restoreKeys?: string[]): Promise<string | undefined>;
 export declare function saveToCache(cachePath: string[], key: string): Promise<void>;
 /**
  * Generates a cache key

dist/src/cache/build-cache.d.ts

@@ -0,0 +1,173 @@
+import { info, warning } from '@actions/core';
+import { createHash } from 'crypto';
+import { existsSync, readFileSync } from 'fs';
+import { Cargo } from '../rust/cargo';
+import { restoreFromCache, saveToCache } from './cache-impl';
+
+export interface BuildCacheStrategy {
+  restore(): Promise<void>;
+  save(): Promise<void>;
+}
+
+export function buildCacheStrategy(
+  projectDir: string,
+  strategy: string,
+  toolchains: string[],
+  fallbackBranch: string,
+): BuildCacheStrategy | undefined {
+  switch (strategy) {
+    case 'github':
+      return new GithubBuildCacheStrategy(
+        projectDir,
+        toolchains,
+        fallbackBranch,
+      );
+    case 'none':
+      return undefined;
+    default:
+      warning(`Unknown build cache strategy: ${strategy}`);
+      return undefined;
+  }
+}
+
+export class GithubBuildCacheStrategy implements BuildCacheStrategy {
+  private cacheKey: string;
+  private fallbackKey: string;
+  private projectDir: string;
+  private fallbackBranch: string;
+
+  private restoredFrom: string | undefined;
+
+  constructor(
+    projectDir: string,
+    toolchains: string[],
+    fallbackBranch: string,
+  ) {
+    this.projectDir = projectDir;
+    this.fallbackBranch = fallbackBranch;
+    this.cacheKey = GithubBuildCacheStrategy.buildCacheKey(
+      projectDir,
+      toolchains,
+      fallbackBranch,
+    );
+    this.fallbackKey = GithubBuildCacheStrategy.buildFallbackCacheKey(
+      projectDir,
+      toolchains,
+      fallbackBranch,
+    );
+  }
+
+  async restore(): Promise<void> {
+    this.restoredFrom = await GithubBuildCacheStrategy.restoreBuildCache(
+      this.projectDir,
+      this.cacheKey,
+      this.fallbackKey,
+    );
+  }
+
+  async save(): Promise<void> {
+    const currentBranch = process.env.GITHUB_REF_NAME || 'not-in-gh-action';
+
+    // Always save if this is the fallback branch
+    // Skip save if no dependencies changed
+    if (
+      currentBranch !== this.fallbackBranch &&
+      this.restoredFrom === this.cacheKey
+    ) {
+      info(`Build cache dependencies unchanged, skipping save.`);
+      return;
+    }
+
+    await GithubBuildCacheStrategy.saveBuildCache(
+      this.projectDir,
+      this.cacheKey,
+    );
+  }
+
+  static async restoreBuildCache(
+    projectDir: string,
+    cacheKey: string,
+    fallbackKey: string,
+  ): Promise<string | undefined> {
+    const targetDir = Cargo.targetDir(projectDir);
+
+    const restoredKey = await restoreFromCache([targetDir], cacheKey, [
+      fallbackKey,
+    ]);
+
+    if (restoredKey) {
+      console.info(`Restored build cache from key: ${restoredKey}`);
+    } else {
+      console.info(
+        `No build cache found for keys: ${cacheKey}, ${fallbackKey}`,
+      );
+    }
+
+    return restoredKey;
+  }
+
+  static async saveBuildCache(projectDir: string, cacheKey: string) {
+    const targetDir = Cargo.targetDir(projectDir);
+
+    if (!existsSync(targetDir)) {
+      warning(
+        `Target directory does not exist: ${targetDir}, skipping cache save.`,
+      );
+      return;
+    }
+
+    await saveToCache([targetDir], cacheKey);
+    info(`Saved build cache with key: ${cacheKey}`);
+  }
+
+  static buildCacheKey(
+    projectDir: string,
+    toolchains: string[],
+    fallbackBranch: string,
+  ): string {
+    const lockFile = Cargo.cargoLock(projectDir);
+    let lockHashOrBranch = process.env.GITHUB_REF_NAME || 'not-in-gh-action';
+
+    if (fallbackBranch === lockHashOrBranch) {
+      // Use branch name
+    } else if (existsSync(lockFile)) {
+      const lockContent = readFileSync(lockFile, 'utf8');
+      const hash = createHash('sha256').update(lockContent).digest('hex');
+      lockHashOrBranch = hash.slice(0, 20);
+    }
+
+    const toolchainHash = createHash('sha256')
+      .update(toolchains.sort().join(','))
+      .digest('hex')
+      .slice(0, 8);
+
+    let normalizedProjectDir = projectDir
+      .trim()
+      .replace(/^[./\\]+/, '')
+      .replace(/[./\\]+$/, '')
+      .replace(/^[/\\]+/, '');
+
+    if (!normalizedProjectDir) normalizedProjectDir = 'root';
+    normalizedProjectDir = normalizedProjectDir.replace(/[\\/]+/g, '-');
+
+    const platform = process.platform;
+    const arch = process.arch;
+
+    return `rax-cache-build-${platform}-${arch}-${toolchainHash}-${normalizedProjectDir}-${lockHashOrBranch}`;
+  }
+
+  static buildFallbackCacheKey(
+    projectDir: string,
+    toolchains: string[],
+    fallbackBranch: string,
+  ): string {
+    const platform = process.platform;
+    const arch = process.arch;
+    const toolchainHash = createHash('sha256')
+      .update(toolchains.sort().join(','))
+      .digest('hex')
+      .slice(0, 8);
+
+    return `rax-cache-build-${platform}-${arch}-${toolchainHash}-${projectDir}-${fallbackBranch}`;
+  }
+}