25288371112

Committed 03 May 2026 07:20PM UTC coverage: 92.634% (-0.8%) from 93.454%

Build # 25288371112

Build Type

push

github

Committed by

web-flow

Commit Message

Bump the vitest group (#84)

#skip-auto-release

Coverage Stats

152 of 169 branches covered (89.94%)

Branch coverage included in aggregate %.

263 of 279 relevant lines covered (94.27%)

11.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.0

/src/OctokitPluginRequestCache.ts

import * as actionsCache from "@actions/cache";
import { hash } from "crypto";
import { join as pathJoin } from "path";
import { mkdir } from "fs/promises";
import type { Octokit } from "@octokit/core";
import type { RequestParameters } from "@octokit/types";

import { ETagRequestCacheDB } from "./ETagRequestCacheDB";

interface OctokitPluginRequestCacheOptions {
    actionsCache?: typeof actionsCache;
    enable?: boolean;
    requestCache?: ETagRequestCacheDB
}

interface OctokitPluginRequestCacheReturn {
    loadCache: (primaryKey: string, restoreKey: string) => Promise<void>;
    saveCache: (primaryKey: string) => Promise<void>;
}

const CACHE_DIR = pathJoin("/", "tmp", ".cache", "preceding-tag-action");

function mapObject(obj: Record<string, unknown>, callback: (key: string, value: unknown) => unknown): Record<string, unknown> {
    return Object.entries(obj).reduce((result, [key, value]: [string, any]) => {
        const mappedValue = callback(key, value);
        if (mappedValue !== undefined) {
            result[key] = mappedValue;
        }

        return result;
    }, {} as Record<string, unknown>);
}

function hashRequestParameters(requestParameters: RequestParameters): string {
    const headerMapper = (key: string, value: unknown): unknown => {
        if (key !== "accept") {
            return undefined;
        }

        return value;
    };

    const mediaTypeMapper = (key: string, value: unknown): unknown => {
        if (key !== "format") {
            return undefined;
        }

        return value;
    };

    const objectToHash = mapObject(requestParameters, (key, value) => {
        if (key === "request") {
            return undefined;
        }

        if (key === "headers") {
            return mapObject(value as any, headerMapper);
        }

        if (key === "mediaType") {
            return mapObject(value as any, mediaTypeMapper);
        }

        return value;
    });

    return hash("sha256", JSON.stringify(objectToHash));
}

export function requestCache(octokit: Octokit, options: OctokitPluginRequestCacheOptions | any): OctokitPluginRequestCacheReturn {
    const optionsWithDefaults = {
        actionsCache: actionsCache,
        enable: true,
        requestCache: new ETagRequestCacheDB(),
        ...options as OctokitPluginRequestCacheOptions
    } satisfies Required<OctokitPluginRequestCacheOptions>;

    // Early return if disabled
    if (!optionsWithDefaults.enable) {
        return {
            loadCache: (): Promise<void> => Promise.resolve(),
            saveCache: (): Promise<void> => Promise.resolve()
        };
    }

    octokit.hook.before("request", async (options) => {
        if (!(await optionsWithDefaults.requestCache.isOpen())) {
            return;
        }

        let cacheControl = options.headers["cache-control"];
        cacheControl = cacheControl == null ? "" : cacheControl.toString();
        if (cacheControl.includes("no-cache")) {
            return;
        }

        const requestHash = hashRequestParameters(options);
        const eTag = await optionsWithDefaults.requestCache.matchETag(requestHash);
        if (eTag != null) {
            options.headers["If-None-Match"] = eTag;
        }
    });

    octokit.hook.after("request", async (response, options) => {
        if (!(await optionsWithDefaults.requestCache.isOpen())) {
            return;
        }

        let cacheControl = options.headers["cache-control"];
        cacheControl = cacheControl == null ? "" : cacheControl.toString();
        if (cacheControl.includes("no-store")) {
            return;
        }

        if (response.headers.etag != null) {
            const etagMatcher = response.headers.etag.match(/("[^"]+")/);
            if (etagMatcher != null && etagMatcher[1] != null) {
                const etag = etagMatcher[1];
                const requestHash = hashRequestParameters(options);
                optionsWithDefaults.requestCache.put(requestHash, etag, response, Date.now());
            }
        }
    });

    octokit.hook.error("request", async (error: any) => {
        if (!(await optionsWithDefaults.requestCache.isOpen())) {
            return;
        }

        if (error.status === 304 && error.response != null && error.response.headers != null && error.response.headers.etag != null) {
            const cachedResponse = await optionsWithDefaults.requestCache.matchResponse(error.response.headers.etag);
            if (cachedResponse != null) {
                return cachedResponse.response;
            }
        }

        throw error;
    });

    return {
        async loadCache(primaryKey: string, restoreKey: string): Promise<void> {
            await mkdir(CACHE_DIR, {recursive: true});
            await optionsWithDefaults.actionsCache.restoreCache([pathJoin(CACHE_DIR, "*")], primaryKey, [restoreKey]);
            await optionsWithDefaults.requestCache.open();
        },
        async saveCache(primaryKey: string): Promise<void> {
            await optionsWithDefaults.requestCache.close();
            await optionsWithDefaults.actionsCache.saveCache([pathJoin(CACHE_DIR, "*")], primaryKey);
        }
    };
}

1	import * as actionsCache from "@actions/cache";
2	import { hash } from "crypto";
3	import { join as pathJoin } from "path";
4	import { mkdir } from "fs/promises";
5	import type { Octokit } from "@octokit/core";
6	import type { RequestParameters } from "@octokit/types";
7
8	import { ETagRequestCacheDB } from "./ETagRequestCacheDB";
9
10	interface OctokitPluginRequestCacheOptions {
11	actionsCache?: typeof actionsCache;
12	enable?: boolean;
13	requestCache?: ETagRequestCacheDB
14	}
15
16	interface OctokitPluginRequestCacheReturn {
17	loadCache: (primaryKey: string, restoreKey: string) => Promise<void>;
18	saveCache: (primaryKey: string) => Promise<void>;
19	}
20
21	const CACHE_DIR = pathJoin("/", "tmp", ".cache", "preceding-tag-action");	2✔
22
23	function mapObject(obj: Record<string, unknown>, callback: (key: string, value: unknown) => unknown): Record<string, unknown> {
24	return Object.entries(obj).reduce((result, [key, value]: [string, any]) => {	9✔
25	const mappedValue = callback(key, value);	24✔
26	if (mappedValue !== undefined) {	24✔
27	result[key] = mappedValue;	15✔
28	}
29
30	return result;	24✔
31	}, {} as Record<string, unknown>);
32	}
33
34	function hashRequestParameters(requestParameters: RequestParameters): string {
35	const headerMapper = (key: string, value: unknown): unknown => {	3✔
36	if (key !== "accept") {	6✔
37	return undefined;	3✔
38	}
39
40	return value;	3✔
41	};
42
43	const mediaTypeMapper = (key: string, value: unknown): unknown => {	3✔
44	if (key !== "format") {	6✔
45	return undefined;	3✔
46	}
47
48	return value;	3✔
49	};
50
51	const objectToHash = mapObject(requestParameters, (key, value) => {	3✔
52	if (key === "request") {	12✔
53	return undefined;	3✔
54	}
55
56	if (key === "headers") {	9✔
57	return mapObject(value as any, headerMapper);	3✔
58	}
59
60	if (key === "mediaType") {	6✔
61	return mapObject(value as any, mediaTypeMapper);	3✔
62	}
63
64	return value;	3✔
65	});
66
67	return hash("sha256", JSON.stringify(objectToHash));	3✔
68	}
69
70	export function requestCache(octokit: Octokit, options: OctokitPluginRequestCacheOptions \| any): OctokitPluginRequestCacheReturn {
71	const optionsWithDefaults = {	5✔
72	actionsCache: actionsCache,
73	enable: true,
74	requestCache: new ETagRequestCacheDB(),
75	...options as OctokitPluginRequestCacheOptions
76	} satisfies Required<OctokitPluginRequestCacheOptions>;
77
78	// Early return if disabled
79	if (!optionsWithDefaults.enable) {	5✔
80	return {	1✔
81	loadCache: (): Promise<void> => Promise.resolve(),	×
82	saveCache: (): Promise<void> => Promise.resolve()	×
83	};
84	}
85
86	octokit.hook.before("request", async (options) => {	4✔
87	if (!(await optionsWithDefaults.requestCache.isOpen())) {	4!
88	return;	×
89	}
90
91	let cacheControl = options.headers["cache-control"];	4✔
92	cacheControl = cacheControl == null ? "" : cacheControl.toString();	4✔
93	if (cacheControl.includes("no-cache")) {	4✔
94	return;	2✔
95	}
96
97	const requestHash = hashRequestParameters(options);	2✔
98	const eTag = await optionsWithDefaults.requestCache.matchETag(requestHash);	2✔
99	if (eTag != null) {	2✔
100	options.headers["If-None-Match"] = eTag;	1✔
101	}
102	});
103
104	octokit.hook.after("request", async (response, options) => {	4✔
105	if (!(await optionsWithDefaults.requestCache.isOpen())) {	2!
106	return;	×
107	}
108
109	let cacheControl = options.headers["cache-control"];	2✔
110	cacheControl = cacheControl == null ? "" : cacheControl.toString();	2✔
111	if (cacheControl.includes("no-store")) {	2✔
112	return;	1✔
113	}
114
115	if (response.headers.etag != null) {	1!
116	const etagMatcher = response.headers.etag.match(/("[^"]+")/);	1✔
117	if (etagMatcher != null && etagMatcher[1] != null) {	1!
118	const etag = etagMatcher[1];	1✔
119	const requestHash = hashRequestParameters(options);	1✔
120	optionsWithDefaults.requestCache.put(requestHash, etag, response, Date.now());	1✔
121	}
122	}
123	});
124
125	octokit.hook.error("request", async (error: any) => {	4✔
126	if (!(await optionsWithDefaults.requestCache.isOpen())) {	2!
127	return;	×
128	}
129
130	if (error.status === 304 && error.response != null && error.response.headers != null && error.response.headers.etag != null) {	2!
131	const cachedResponse = await optionsWithDefaults.requestCache.matchResponse(error.response.headers.etag);	2✔
132	if (cachedResponse != null) {	2✔
133	return cachedResponse.response;	1✔
134	}
135	}
136
137	throw error;	1✔
138	});
139
140	return {	4✔
141	async loadCache(primaryKey: string, restoreKey: string): Promise<void> {
142	await mkdir(CACHE_DIR, {recursive: true});	2✔
143	await optionsWithDefaults.actionsCache.restoreCache([pathJoin(CACHE_DIR, "*")], primaryKey, [restoreKey]);	2✔
144	await optionsWithDefaults.requestCache.open();	2✔
145	},
146	async saveCache(primaryKey: string): Promise<void> {
147	await optionsWithDefaults.requestCache.close();	2✔
148	await optionsWithDefaults.actionsCache.saveCache([pathJoin(CACHE_DIR, "*")], primaryKey);	2✔
149	}
150	};
151	}

AJGranowski / preceding-tag-action / 25288371112

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous