10880886506

Committed 16 Sep 2024 09:15AM UTC coverage: 68.847% (-1.4%) from 70.266%

Build # 10880886506

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #437 from fastrodev/store

Store: make TTL optionally

Run Details

110 of 155 branches covered (70.97%)

Branch coverage included in aggregate %.

15 of 138 new or added lines in 2 files covered. (10.87%)

14 existing lines in 1 file now uncovered.

1132 of 1649 relevant lines covered (68.65%)

16.36 hits per line

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

23.39

/core/map/map.ts

// deno-lint-ignore-file no-explicit-any
import { Octokit } from "npm:@octokit/rest";

type StoreOptions = {
    owner: string;
    repo: string;
    path: string;
    token: string;
    branch?: string;
} | null;

export class Store<K extends string | number | symbol, V> {
    private map: Map<K, { value: V; expiry?: number }>;
    private options: StoreOptions;
    private saveIntervalId: number | null = null;
    private isCommitting: boolean = false;

    constructor(options: StoreOptions = null) {
        this.map = new Map<K, { value: V; expiry?: number }>();
        this.options = options;
    }

    set(key: K, value: V, ttl?: number): void {
        const expiry = ttl ? Date.now() + ttl : undefined;
        this.map.set(key, { value, expiry });
    }

    async refresh() {
        if (this.map.size === 0 && this.options) {
            const map = await getMap<K, V>({
                token: this.options.token,
                owner: this.options.owner,
                repo: this.options.repo,
                path: this.options.path,
                branch: this.options.branch,
            });
            if (!map) return;
            this.map = map;
        }
    }

    async get(key: K): Promise<V | undefined> {
        await this.refresh();
        const entry = this.map.get(key);
        if (entry) {
            if (entry.expiry === undefined || Date.now() < entry.expiry) {
                return entry.value;
            } else {
                this.map.delete(key);
            }
        }
        return undefined;
    }

    async has(key: K): Promise<boolean> {
        await this.refresh();
        const entry = this.map.get(key);
        if (entry) {
            if (entry.expiry === undefined || Date.now() < entry.expiry) {
                return true;
            } else {
                this.map.delete(key);
            }
        }
        return false;
    }

    delete(key: K): boolean {
        return this.map.delete(key);
    }

    clear(): void {
        this.map.clear();
    }

    size(): number {
        this.cleanUpExpiredEntries();
        return this.map.size;
    }

    entries() {
        this.cleanUpExpiredEntries();
        return this.map.entries();
    }

    values() {
        this.cleanUpExpiredEntries();
        return this.map.values();
    }

    keys() {
        this.cleanUpExpiredEntries();
        return this.map.keys();
    }

    forEach(callback: (value: V, key: K) => void): void {
        this.cleanUpExpiredEntries();
        this.map.forEach((entry, key) => {
            callback(entry.value, key);
        });
    }

    /**
     * Save to github
     */
    async commit() {
        if (this.isCommitting) {
            throw new Error("Commit in progress, please wait.");
        }

        this.isCommitting = true;
        try {
            this.cleanUpExpiredEntries();
            if (!this.options) throw new Error("Options is needed.");
            const x = await this.saveToGitHub(
                {
                    token: this.options.token,
                    owner: this.options.owner,
                    repo: this.options.repo,
                    path: this.options.path,
                    branch: this.options.branch,
                },
            );
            return x;
        } finally {
            this.isCommitting = false;
        }
    }

    async destroy() {
        this.map.clear();
        if (!this.options) throw new Error("Options is needed.");
        return await deleteGithubFile({
            token: this.options.token,
            repoOwner: this.options.owner,
            repoName: this.options.repo,
            filePath: this.options.path,
            branch: this.options.branch,
        });
    }

    startAutoSave(interval: number): void {
        if (this.saveIntervalId) {
            clearInterval(this.saveIntervalId);
        }

        this.saveIntervalId = setInterval(() => {
            if (!this.options || this.map.size === 0) return;
            return this.saveToGitHub({
                token: this.options.token,
                owner: this.options.owner,
                repo: this.options.repo,
                path: this.options.path,
                branch: this.options.branch,
            });
        }, interval);
    }

    private async saveToGitHub(
        options: {
            token: string;
            owner: string;
            repo: string;
            path: string;
            branch?: string;
        },
    ) {
        try {
            if (this.options) {
                const record = mapToRecord(this.map);
                const data = JSON.stringify(record);
                return await uploadFileToGitHub(
                    {
                        token: options.token,
                        repoOwner: options.owner,
                        repoName: options.repo,
                        filePath: options.path,
                        fileContent: data,
                        branch: options.branch,
                    },
                );
            }
        } catch (error) {
            throw error;
        }
    }

    private cleanUpExpiredEntries(): void {
        for (const [key, entry] of this.map.entries()) {
            if (entry.expiry !== undefined && Date.now() >= entry.expiry) {
                this.map.delete(key);
            }
        }
    }
}

function recordToMap<K extends string | number | symbol, V>(
    record: Record<K, { value: V; expiry: number }>,
): Map<K, { value: V; expiry?: number }> {
    const map = new Map<K, { value: V; expiry: number }>();

    Object.entries(record).forEach(([key, value]) => {
        map.set(key as K, value as { value: V; expiry: number });
    });

    return map;
}

function mapToRecord<K extends string | number | symbol, V>(
    map: Map<K, V>,
): Record<K, V> {
    return Object.fromEntries(map) as Record<K, V>;
}

async function getSHA(
    options: {
        token: string;
        repoOwner: string;
        repoName: string;
        filePath: string;
        branch?: string;
    },
): Promise<string | undefined> {
    const octokit = new Octokit({ auth: options.token });
    try {
        const response = await octokit.repos.getContent({
            owner: options.repoOwner,
            repo: options.repoName,
            path: options.filePath,
            ref: options.branch,
        }) as any;

        return response.data.sha;
    } catch (error) {
        throw error;
    }
}

async function uploadFileToGitHub(
    options: {
        token: string;
        repoOwner: string;
        repoName: string;
        filePath: string;
        fileContent: string;
        branch?: string;
    },
) {
    const octokit = new Octokit({ auth: options.token });
    try {
        const res = await getFileFromGithub(
            {
                token: options.token,
                repoOwner: options.repoOwner,
                repoName: options.repoName,
                filePath: options.filePath,
                branch: options.branch,
            },
        ) as any;

        const sha = res
            ? await getSHA({
                token: options.token,
                repoOwner: options.repoOwner,
                repoName: options.repoName,
                filePath: options.filePath,
                branch: options.branch,
            })
            : undefined;

        const message = res
            ? `Update ${options.filePath}`
            : `Create ${options.filePath}`;
        return await octokit.repos.createOrUpdateFileContents({
            owner: options.repoOwner,
            repo: options.repoName,
            path: options.filePath,
            message,
            content: btoa(options.fileContent),
            sha,
            branch: options.branch,
        });
    } catch (error) {
        throw error;
    }
}

async function getMap<K extends string | number | symbol, V>(
    options: {
        token: string;
        owner: string;
        repo: string;
        path: string;
        branch?: string;
    },
) {
    const rr = await getFileFromGithub(
        {
            token: options.token,
            repoOwner: options.owner,
            repoName: options.repo,
            filePath: options.path,
            branch: options.branch,
        },
    ) as any;
    if (!rr) return;
    const data = atob(rr.content);
    return recordToMap<K, V>(JSON.parse(data));
}

async function getFileFromGithub(options: {
    token: string;
    repoOwner: string;
    repoName: string;
    filePath: string;
    branch?: string;
}) {
    const octokit = new Octokit({ auth: options.token });
    try {
        const res = await octokit.repos.getContent({
            owner: options.repoOwner,
            repo: options.repoName,
            path: options.filePath,
            ref: options.branch,
        });
        return res.data;
    } catch {
        return undefined;
    }
}

async function deleteGithubFile(
    options: {
        token: string;
        repoOwner: string;
        repoName: string;
        filePath: string;
        branch?: string;
    },
) {
    const octokit = new Octokit({ auth: options.token });
    try {
        const sha = await getSHA({
            token: options.token,
            repoOwner: options.repoOwner,
            repoName: options.repoName,
            filePath: options.filePath,
            branch: options.branch,
        });
        if (!sha) throw new Error("SHA is needed");
        const res = await octokit.repos.deleteFile({
            owner: options.repoOwner,
            repo: options.repoName,
            path: options.filePath,
            sha,
            branch: options.branch,
            message: `Delete ${options.filePath}`,
        });
        return res.data;
    } catch (error) {
        throw error;
    }
}

1	// deno-lint-ignore-file no-explicit-any	1✔
2	import { Octokit } from "npm:@octokit/rest";	3✔
3
4	type StoreOptions = {
5	owner: string;
6	repo: string;
7	path: string;
8	token: string;
9	branch?: string;
10	} \| null;
11
12	export class Store<K extends string \| number \| symbol, V> {	3✔
13	private map: Map<K, { value: V; expiry?: number }>;	3✔
14	private options: StoreOptions;	13✔
15	private saveIntervalId: number \| null = null;	13✔
16	private isCommitting: boolean = false;	3✔
17
18	constructor(options: StoreOptions = null) {	3✔
19	this.map = new Map<K, { value: V; expiry?: number }>();	13✔
20	this.options = options;	13✔
21	}	13✔
22
23	set(key: K, value: V, ttl?: number): void {	3✔
24	const expiry = ttl ? Date.now() + ttl : undefined;	12✔
25	this.map.set(key, { value, expiry });	48✔
26	}	12✔
27
28	async refresh() {	3✔
29	if (this.map.size === 0 && this.options) {	×
NEW 30	const map = await getMap<K, V>({	×
NEW 31	token: this.options.token,	×
NEW 32	owner: this.options.owner,	×
NEW 33	repo: this.options.repo,	×
NEW 34	path: this.options.path,	×
NEW 35	branch: this.options.branch,	×
NEW 36	});	×
NEW 37	if (!map) return;	×
NEW 38	this.map = map;	×
UNCOV 39	}	×
40	}	9✔
41
42	async get(key: K): Promise<V \| undefined> {	3✔
43	await this.refresh();	6✔
44	const entry = this.map.get(key);	6✔
45	if (entry) {	6✔
46	if (entry.expiry === undefined \|\| Date.now() < entry.expiry) {	6✔
47	return entry.value;	8✔
48	} else {	6✔
49	this.map.delete(key);	7✔
50	}	7✔
51	}	6✔
52	return undefined;	7✔
53	}	6✔
54
55	async has(key: K): Promise<boolean> {	3✔
56	await this.refresh();	6✔
57	const entry = this.map.get(key);	6✔
58	if (entry) {	6✔
59	if (entry.expiry === undefined \|\| Date.now() < entry.expiry) {	8✔
60	return true;	9✔
61	} else {	9✔
62	this.map.delete(key);	9✔
63	}	9✔
64	}	8✔
65	return false;	8✔
66	}	6✔
67
68	delete(key: K): boolean {	3✔
69	return this.map.delete(key);	4✔
70	}	4✔
71
72	clear(): void {	3✔
73	this.map.clear();	4✔
74	}	4✔
75
76	size(): number {	3✔
77	this.cleanUpExpiredEntries();	5✔
78	return this.map.size;	5✔
79	}	5✔
80
81	entries() {	×
82	this.cleanUpExpiredEntries();	×
83	return this.map.entries();	×
84	}	×
85
86	values() {	×
87	this.cleanUpExpiredEntries();	×
88	return this.map.values();	×
89	}	×
90
91	keys() {	×
92	this.cleanUpExpiredEntries();	×
93	return this.map.keys();	×
94	}	×
95
UNCOV 96	forEach(callback: (value: V, key: K) => void): void {	×
UNCOV 97	this.cleanUpExpiredEntries();	×
UNCOV 98	this.map.forEach((entry, key) => {	×
UNCOV 99	callback(entry.value, key);	×
UNCOV 100	});	×
UNCOV 101	}	×
102
103	/**	3✔
104	* Save to github
NEW 105	*/	×
106	async commit() {	×
NEW 107	if (this.isCommitting) {	×
NEW 108	throw new Error("Commit in progress, please wait.");	×
NEW 109	}	×
110
NEW 111	this.isCommitting = true;	×
NEW 112	try {	×
NEW 113	this.cleanUpExpiredEntries();	×
NEW 114	if (!this.options) throw new Error("Options is needed.");	×
NEW 115	const x = await this.saveToGitHub(	×
NEW 116	{	×
NEW 117	token: this.options.token,	×
NEW 118	owner: this.options.owner,	×
NEW 119	repo: this.options.repo,	×
NEW 120	path: this.options.path,	×
NEW 121	branch: this.options.branch,	×
NEW 122	},	×
123	);
NEW 124	return x;	×
NEW 125	} finally {	×
NEW 126	this.isCommitting = false;	×
NEW 127	}	×
UNCOV 128	}	×
129
130	async destroy() {	×
131	this.map.clear();	×
132	if (!this.options) throw new Error("Options is needed.");	×
NEW 133	return await deleteGithubFile({	×
NEW 134	token: this.options.token,	×
NEW 135	repoOwner: this.options.owner,	×
NEW 136	repoName: this.options.repo,	×
NEW 137	filePath: this.options.path,	×
NEW 138	branch: this.options.branch,	×
NEW 139	});	×
UNCOV 140	}	×
141
142	startAutoSave(interval: number): void {	3✔
143	if (this.saveIntervalId) {	×
144	clearInterval(this.saveIntervalId);	×
145	}	×
146
147	this.saveIntervalId = setInterval(() => {	×
148	if (!this.options \|\| this.map.size === 0) return;	×
NEW 149	return this.saveToGitHub({	×
NEW 150	token: this.options.token,	×
NEW 151	owner: this.options.owner,	×
NEW 152	repo: this.options.repo,	×
NEW 153	path: this.options.path,	×
NEW 154	branch: this.options.branch,	×
NEW 155	});	×
UNCOV 156	}, interval);	×
157	}	6✔
158
UNCOV 159	private async saveToGitHub(	×
NEW 160	options: {	×
161	token: string;
162	owner: string;
163	repo: string;
164	path: string;
165	branch?: string;
NEW 166	},	×
167	) {	×
168	try {	×
169	if (this.options) {	×
170	const record = mapToRecord(this.map);	×
171	const data = JSON.stringify(record);	×
172	return await uploadFileToGitHub(	×
NEW 173	{	×
NEW 174	token: options.token,	×
NEW 175	repoOwner: options.owner,	×
NEW 176	repoName: options.repo,	×
NEW 177	filePath: options.path,	×
NEW 178	fileContent: data,	×
NEW 179	branch: options.branch,	×
NEW 180	},	×
181	);
182	}	×
183	} catch (error) {	×
184	throw error;	×
185	}	×
186	}	×
187
188	private cleanUpExpiredEntries(): void {	3✔
189	for (const [key, entry] of this.map.entries()) {	5✔
NEW 190	if (entry.expiry !== undefined && Date.now() >= entry.expiry) {	×
191	this.map.delete(key);	×
192	}	×
193	}	5✔
194	}	5✔
195	}	3✔
196
197	function recordToMap<K extends string \| number \| symbol, V>(	×
198	record: Record<K, { value: V; expiry: number }>,	×
199	): Map<K, { value: V; expiry?: number }> {
200	const map = new Map<K, { value: V; expiry: number }>();	×
201
202	Object.entries(record).forEach(([key, value]) => {	×
203	map.set(key as K, value as { value: V; expiry: number });	×
204	});	×
205
206	return map;	×
207	}	×
208
209	function mapToRecord<K extends string \| number \| symbol, V>(	×
210	map: Map<K, V>,	×
211	): Record<K, V> {
212	return Object.fromEntries(map) as Record<K, V>;	×
213	}	×
214
215	async function getSHA(	×
NEW 216	options: {	×
217	token: string;
218	repoOwner: string;
219	repoName: string;
220	filePath: string;
221	branch?: string;
NEW 222	},	×
223	): Promise<string \| undefined> {
NEW 224	const octokit = new Octokit({ auth: options.token });	×
UNCOV 225	try {	×
226	const response = await octokit.repos.getContent({	×
NEW 227	owner: options.repoOwner,	×
NEW 228	repo: options.repoName,	×
NEW 229	path: options.filePath,	×
NEW 230	ref: options.branch,	×
UNCOV 231	}) as any;	×
232
233	return response.data.sha;	×
234	} catch (error) {	×
235	throw error;	×
236	}	×
237	}	×
238
239	async function uploadFileToGitHub(	×
NEW 240	options: {	×
241	token: string;
242	repoOwner: string;
243	repoName: string;
244	filePath: string;
245	fileContent: string;
246	branch?: string;
NEW 247	},	×
248	) {
NEW 249	const octokit = new Octokit({ auth: options.token });	×
250	try {	×
251	const res = await getFileFromGithub(	×
NEW 252	{	×
NEW 253	token: options.token,	×
NEW 254	repoOwner: options.repoOwner,	×
NEW 255	repoName: options.repoName,	×
NEW 256	filePath: options.filePath,	×
NEW 257	branch: options.branch,	×
NEW 258	},	×
259	) as any;
260
261	const sha = res	×
NEW 262	? await getSHA({	×
NEW 263	token: options.token,	×
NEW 264	repoOwner: options.repoOwner,	×
NEW 265	repoName: options.repoName,	×
NEW 266	filePath: options.filePath,	×
NEW 267	branch: options.branch,	×
NEW 268	})	×
UNCOV 269	: undefined;	×
270
NEW 271	const message = res	×
NEW 272	? `Update ${options.filePath}`	×
NEW 273	: `Create ${options.filePath}`;	×
274	return await octokit.repos.createOrUpdateFileContents({	×
NEW 275	owner: options.repoOwner,	×
NEW 276	repo: options.repoName,	×
NEW 277	path: options.filePath,	×
278	message,	×
NEW 279	content: btoa(options.fileContent),	×
280	sha,	×
NEW 281	branch: options.branch,	×
282	});	×
283	} catch (error) {	×
284	throw error;	×
285	}	×
286	}	×
287
NEW 288	async function getMap<K extends string \| number \| symbol, V>(	×
NEW 289	options: {	×
290	token: string;
291	owner: string;
292	repo: string;
293	path: string;
294	branch?: string;
NEW 295	},	×
296	) {
NEW 297	const rr = await getFileFromGithub(	×
NEW 298	{	×
NEW 299	token: options.token,	×
NEW 300	repoOwner: options.owner,	×
NEW 301	repoName: options.repo,	×
NEW 302	filePath: options.path,	×
NEW 303	branch: options.branch,	×
NEW 304	},	×
305	) as any;
NEW 306	if (!rr) return;	×
NEW 307	const data = atob(rr.content);	×
NEW 308	return recordToMap<K, V>(JSON.parse(data));	×
NEW 309	}	×
310
NEW 311	async function getFileFromGithub(options: {	×
312	token: string;
313	repoOwner: string;
314	repoName: string;
315	filePath: string;
316	branch?: string;
NEW 317	}) {	×
NEW 318	const octokit = new Octokit({ auth: options.token });	×
319	try {	×
320	const res = await octokit.repos.getContent({	×
NEW 321	owner: options.repoOwner,	×
NEW 322	repo: options.repoName,	×
NEW 323	path: options.filePath,	×
NEW 324	ref: options.branch,	×
325	});	×
326	return res.data;	×
327	} catch {	×
328	return undefined;	×
329	}	×
330	}	×
331
332	async function deleteGithubFile(	×
NEW 333	options: {	×
334	token: string;
335	repoOwner: string;
336	repoName: string;
337	filePath: string;
338	branch?: string;
NEW 339	},	×
340	) {
NEW 341	const octokit = new Octokit({ auth: options.token });	×
342	try {	×
NEW 343	const sha = await getSHA({	×
NEW 344	token: options.token,	×
NEW 345	repoOwner: options.repoOwner,	×
NEW 346	repoName: options.repoName,	×
NEW 347	filePath: options.filePath,	×
NEW 348	branch: options.branch,	×
NEW 349	});	×
350	if (!sha) throw new Error("SHA is needed");	×
351	const res = await octokit.repos.deleteFile({	×
NEW 352	owner: options.repoOwner,	×
NEW 353	repo: options.repoName,	×
NEW 354	path: options.filePath,	×
355	sha,	×
NEW 356	branch: options.branch,	×
NEW 357	message: `Delete ${options.filePath}`,	×
358	});	×
359	return res.data;	×
360	} catch (error) {	×
361	throw error;	×
362	}	×
363	}	×

fastrodev / fastro / 10880886506

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