react-native-cache-build-gitlab 1.0.8 → 1.0.10

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { providerGitLab } from "./provider-gitlab/providerGitlab.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { providerGitLab } from "./provider-gitlab/providerGitlab.js";

package/dist/provider-gitlab/artifacts.d.ts

@@ -0,0 +1,19 @@
+import { type RemoteArtifact } from "@rock-js/tools";
+export type GitLabRepoDetails = {
+    registryServer: string;
+    projectId: number | string;
+    token: string;
+    tokenHeader: "PRIVATE-TOKEN" | "JOB-TOKEN";
+    packageName: string;
+};
+export type GitLabArtifact = {
+    packageId: number;
+    fileId: number;
+    name: string;
+    version: string;
+    sizeInBytes: number;
+    createdAt: string;
+    downloadUrl: string;
+};
+export declare function fetchGitLabArtifactsByName(name: string | undefined, repo: GitLabRepoDetails, limit?: number, version?: string): Promise<GitLabArtifact[]>;
+export declare function deleteGitLabArtifacts(artifacts: GitLabArtifact[], repo: GitLabRepoDetails, artifactNameForLog?: string): Promise<RemoteArtifact[]>;

package/dist/provider-gitlab/artifacts.js

@@ -0,0 +1,106 @@
+import { cacheManager, color, colorLink, logger, RockError, } from "@rock-js/tools";
+const PAGE_SIZE = 100;
+function headersFor(repo) {
+    return {
+        [repo.tokenHeader]: repo.token,
+        Accept: "application/json",
+    };
+}
+async function httpJson(url, repo) {
+    const res = await fetch(url, { headers: headersFor(repo) });
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        const info = `${res.status} ${res.statusText}${body ? ` — ${body}` : ""}`;
+        if (res.status === 401 || res.status === 403) {
+            cacheManager.remove("gitlabToken");
+            throw new RockError(`GitLab auth failed.\nUpdate token under ${color.bold("remoteCacheProvider")} in ${colorLink("rock.config.mjs")}. Local uses ${color.bold("PRIVATE-TOKEN")}, CI uses ${color.bold("JOB-TOKEN")}.\nURL: ${colorLink(url)}\nError: ${info}`);
+        }
+        if (res.status === 404) {
+            throw new RockError(`GitLab 404.\nCheck registryServer/projectId/packageName or token perms.\nURL: ${colorLink(url)}`);
+        }
+        throw new RockError(`GitLab request failed: ${info}`);
+    }
+    return (await res.json());
+}
+function genericDownloadUrl(repo, packageName, version, fileName) {
+    const { registryServer, projectId } = repo;
+    return `${registryServer}/api/v4/projects/${encodeURIComponent(String(projectId))}/packages/generic/${encodeURIComponent(packageName)}/${encodeURIComponent(version)}/${encodeURIComponent(fileName)}`;
+}
+export async function fetchGitLabArtifactsByName(name, repo, limit, version) {
+    if (!repo?.token) {
+        throw new RockError("Missing GitLab token. Valid repoDetails.token & tokenHeader pass.");
+    }
+    const perPage = Math.min(limit ?? PAGE_SIZE, PAGE_SIZE);
+    let page = 1;
+    const packages = [];
+    while (true) {
+        const url = `${repo.registryServer}/api/v4/projects/${encodeURIComponent(String(repo.projectId))}/packages` +
+            `?package_type=generic&per_page=${perPage}&page=${page}` +
+            (name ? `&package_name=${encodeURIComponent(name)}` : "");
+        const chunk = await httpJson(url, repo);
+        if (!chunk.length)
+            break;
+        packages.push(...chunk);
+        if (chunk.length < perPage)
+            break;
+        page += 1;
+    }
+    const artifacts = [];
+    for (const pkg of packages) {
+        if (pkg.package_type !== "generic" || !pkg.version)
+            continue;
+        // Don't filter by version here - we'll filter by filename later
+        let fPage = 1;
+        while (true) {
+            const filesUrl = `${repo.registryServer}/api/v4/projects/${encodeURIComponent(String(repo.projectId))}` +
+                `/packages/${pkg.id}/package_files?per_page=${PAGE_SIZE}&page=${fPage}`;
+            const files = await httpJson(filesUrl, repo);
+            if (!files.length)
+                break;
+            for (const file of files) {
+                // If version (fingerprint) is provided, filter by filename containing it
+                if (version && !file.file_name.includes(version))
+                    continue;
+                artifacts.push({
+                    packageId: pkg.id,
+                    fileId: file.id,
+                    name: pkg.name,
+                    version: pkg.version,
+                    sizeInBytes: file.size,
+                    createdAt: file.created_at,
+                    downloadUrl: genericDownloadUrl(repo, pkg.name, pkg.version, file.file_name),
+                });
+            }
+            if (files.length < PAGE_SIZE)
+                break;
+            fPage += 1;
+        }
+    }
+    artifacts.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return artifacts;
+}
+export async function deleteGitLabArtifacts(artifacts, repo, artifactNameForLog) {
+    const deleted = [];
+    try {
+        for (const artifact of artifacts) {
+            const url = `${repo.registryServer}/api/v4/projects/${encodeURIComponent(String(repo.projectId))}/packages/${artifact.packageId}/package_files/${artifact.fileId}`;
+            const res = await fetch(url, {
+                method: "DELETE",
+                headers: headersFor(repo),
+            });
+            if (!res.ok) {
+                logger.warn(`Delete failed packageId=${artifact.packageId}, fileId=${artifact.fileId}: ${res.status} ${res.statusText}`);
+                continue;
+            }
+            deleted.push({
+                name: `${artifact.name}@${artifact.version}`,
+                url: artifact.downloadUrl,
+                id: String(artifact.fileId),
+            });
+        }
+        return deleted;
+    }
+    catch (error) {
+        throw new RockError(`Failed to delete GitLab artifacts${artifactNameForLog ? ` for "${artifactNameForLog}"` : ""}`, { cause: error });
+    }
+}

package/dist/provider-gitlab/config.d.ts

@@ -0,0 +1,8 @@
+import { GitLabRepoDetails } from "./artifacts";
+export type DetectGitLabRepoInput = Partial<GitLabRepoDetails> & {
+    registryServer?: string;
+    projectId?: number | string;
+    token?: string;
+    tokenHeader?: "JOB-TOKEN" | "PRIVATE-TOKEN";
+};
+export declare function detectGitLabRepoDetails(override?: DetectGitLabRepoInput): Promise<GitLabRepoDetails>;

package/dist/provider-gitlab/config.js

@@ -0,0 +1,21 @@
+import { RockError } from "@rock-js/tools";
+export async function detectGitLabRepoDetails(override) {
+    const registryServer = override?.registryServer;
+    const projectId = override?.projectId;
+    const token = override?.token;
+    const tokenHeader = override?.tokenHeader;
+    const packageName = override?.packageName;
+    if (!projectId) {
+        throw new RockError("Missing GitLab projectId. Set GITLAB_PROJECT_ID or pass in override.");
+    }
+    if (!token) {
+        throw new RockError("Missing GitLab token. Use CI_JOB_TOKEN or GITLAB_TOKEN.");
+    }
+    return {
+        registryServer,
+        projectId,
+        token,
+        tokenHeader,
+        packageName,
+    };
+}

package/dist/provider-gitlab/providerGitlab.d.ts

@@ -0,0 +1,36 @@
+import type { RemoteArtifact, RemoteBuildCache } from "@rock-js/tools";
+import { type GitLabRepoDetails } from "./artifacts.js";
+export declare class GitLabBuildCache implements RemoteBuildCache {
+    name: string;
+    repoDetails: GitLabRepoDetails | null;
+    constructor(config?: {
+        registryServer: string;
+        projectId: number | string;
+        token?: string;
+        tokenHeader?: "JOB-TOKEN" | "PRIVATE-TOKEN";
+        packageName: string;
+    });
+    getRepoDetails(): Promise<GitLabRepoDetails>;
+    list({ artifactName, limit, }: {
+        artifactName?: string;
+        limit?: number;
+    }): Promise<RemoteArtifact[]>;
+    download({ artifactName, }: {
+        artifactName: string;
+    }): Promise<Response>;
+    delete({ artifactName, limit, skipLatest, }: {
+        artifactName: string;
+        limit?: number;
+        skipLatest?: boolean;
+    }): Promise<RemoteArtifact[]>;
+    upload(): Promise<RemoteArtifact & {
+        getResponse: (buffer: Buffer | ((registryServer: string) => Buffer), contentType?: string | undefined) => Response;
+    }>;
+}
+export declare const providerGitLab: (options?: {
+    registryServer: string;
+    projectId: number;
+    token?: string;
+    tokenHeader?: "PRIVATE-TOKEN" | "JOB-TOKEN";
+    packageName: string;
+}) => () => RemoteBuildCache;

package/dist/provider-gitlab/providerGitlab.js

@@ -0,0 +1,78 @@
+import { deleteGitLabArtifacts, fetchGitLabArtifactsByName, } from "./artifacts.js";
+import { detectGitLabRepoDetails } from "./config.js";
+function parseRockArtifact(artifactName) {
+    if (!artifactName)
+        return {};
+    const maybe = artifactName.split("-").pop();
+    if (/^[a-f0-9]{40}$/.test(maybe))
+        return { fingerprint: maybe };
+    return {};
+}
+export class GitLabBuildCache {
+    name = "GitLab";
+    repoDetails = null;
+    constructor(config) {
+        if (config) {
+            const token = config.token ?? process.env.CI_JOB_TOKEN;
+            const tokenHeader = config.tokenHeader ?? (process.env.CI ? "JOB-TOKEN" : "PRIVATE-TOKEN");
+            if (!token) {
+                throw new Error("GitLab token is required. Set CI_JOB_TOKEN (CI) or GITLAB_PRIVATE_TOKEN/PRIVATE_TOKEN (local).");
+            }
+            this.repoDetails = {
+                packageName: config.packageName,
+                registryServer: config.registryServer,
+                projectId: config.projectId,
+                token,
+                tokenHeader,
+            };
+        }
+    }
+    async getRepoDetails() {
+        if (!this.repoDetails) {
+            this.repoDetails = await detectGitLabRepoDetails();
+        }
+        return this.repoDetails;
+    }
+    async list({ artifactName, limit, }) {
+        const repo = await this.getRepoDetails();
+        const { fingerprint } = parseRockArtifact(artifactName);
+        const artifacts = await fetchGitLabArtifactsByName(repo.packageName, repo, limit, fingerprint);
+        return artifacts.map((artifact) => ({
+            name: `${artifact.name}@${artifact.version}`,
+            url: artifact.downloadUrl,
+            id: `${artifact.packageId}:${artifact.fileId}`,
+        }));
+    }
+    async download({ artifactName, }) {
+        const repo = await this.getRepoDetails();
+        const { fingerprint } = parseRockArtifact(artifactName);
+        if (!fingerprint)
+            throw new Error("artifactName is required");
+        const list = await fetchGitLabArtifactsByName(repo.packageName, repo, 1, fingerprint);
+        if (list.length === 0) {
+            throw new Error(`No GitLab artifact found for "${artifactName}"${fingerprint ? ` (version=${fingerprint})` : ""}`);
+        }
+        const url = list[0].downloadUrl;
+        return fetch(url, {
+            headers: {
+                [repo.tokenHeader]: repo.token,
+                "Accept-Encoding": "identity",
+            },
+            redirect: "follow",
+        });
+    }
+    async delete({ artifactName, limit, skipLatest, }) {
+        const repo = await this.getRepoDetails();
+        const { fingerprint } = parseRockArtifact(artifactName);
+        const artifacts = await fetchGitLabArtifactsByName(repo.packageName, repo, limit, fingerprint);
+        if (artifacts.length === 0) {
+            throw new Error(`No GitLab artifact found for "${artifactName}"${fingerprint ? ` (version=${fingerprint})` : ""}`);
+        }
+        const list = skipLatest ? artifacts.slice(1) : artifacts;
+        return deleteGitLabArtifacts(list, repo, artifactName);
+    }
+    async upload() {
+        throw new Error("Uploading via RemoteBuildCache is not yet implemented.");
+    }
+}
+export const providerGitLab = (options) => () => new GitLabBuildCache(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-cache-build-gitlab",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "main": "dist/index.js",
   "type": "module",
   "types": "dist/index.d.ts",