11070187911

Committed 27 Sep 2024 11:58AM UTC coverage: 78.529% (-0.8%) from 79.303%

Build # 11070187911

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #459 from fastrodev/dev2

chore: update map/mod.ts

Run Details

123 of 179 branches covered (68.72%)

Branch coverage included in aggregate %.

2 of 9 new or added lines in 1 file covered. (22.22%)

8 existing lines in 1 file now uncovered.

1318 of 1656 relevant lines covered (79.59%)

17.2 hits per line

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

81.6

/core/map/mod.ts

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

type StoreOptions = {
    token?: string;
    owner: string;
    repo: string;
    path: 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 intervalId: number | null = null;
    private isCommitting: boolean = false;

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

    /**
     * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
     * @param key
     * @param value
     * @param ttl
     */
    set(key: K, value: V, ttl?: number) {
        const expiry = ttl ? Date.now() + ttl : undefined;
        this.map.set(key, { value, expiry });
        return this;
    }

    /**
     * @param key
     * @returns boolean indicating whether an element with the specified key exists or not.
     */
    check(key: K) {
        if (this.map.has(key)) {
            throw new Error(`Key ${String(key)} is already used`);
        }

        return this;
    }

    /**
     * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
     * @returns - Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
     */
    async get(key: K) {
        await this.syncMap();
        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;
    }

    /**
     * @param key
     * @returns boolean indicating whether an element with the specified key exists or not.
     */
    async has(key: K) {
        await this.syncMap();
        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;
    }

    /**
     * @param key
     * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
     */
    delete(key: K): boolean {
        return this.map.delete(key);
    }

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

    /**
     * @returns the number of elements in the Map.
     */
    size(): number {
        this.cleanUpExpiredEntries();
        return this.map.size;
    }

    /**
     * @returns an iterable of key, value pairs for every entry in the map.
     */
    entries() {
        this.cleanUpExpiredEntries();
        return this.map.entries();
    }

    /**
     * @returns an iterable of values in the map
     */
    values() {
        this.cleanUpExpiredEntries();
        return this.map.values();
    }

    /**
     * @returns an iterable of keys in the map
     */
    keys() {
        this.cleanUpExpiredEntries();
        return this.map.keys();
    }

    /**
     * Executes a provided function once per each key/value pair in the Map, in insertion order.
     * @param callback
     */
    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.");
        }
        if (!this.options) throw new Error("Options are needed to commit");
        this.isCommitting = true;
        this.cleanUpExpiredEntries();
        try {
            return await this.saveToGitHub(
                {
                    token: this.options.token,
                    owner: this.options.owner,
                    repo: this.options.repo,
                    path: this.options.path,
                    branch: this.options.branch,
                },
            );
        } finally {
            this.isCommitting = false;
        }
    }

    /**
     * Delete file from repository
     */
    async destroy() {
        if (!this.options) throw new Error("Options are needed to destroy.");
        if (this.intervalId) clearInterval(this.intervalId);
        this.map.clear();
        return await deleteGithubFile({
            token: this.options.token,
            owner: this.options.owner,
            repo: this.options.repo,
            path: this.options.path,
            branch: this.options.branch,
        });
    }

    /**
     * Save the map to the repository periodically at intervals
     * @param interval
     * @returns intervalId
     */
    sync(interval: number = 5000) {
        if (this.intervalId) clearInterval(this.intervalId);
        this.intervalId = setInterval(() => {
            if (!this.options || (this.map.size === 0)) return;
            this.saveToGitHub({
                token: this.options.token,
                owner: this.options.owner,
                repo: this.options.repo,
                path: this.options.path,
                branch: this.options.branch,
            }).then((r) => {
                console.log(JSON.stringify({
                    sha: r.data.content?.sha,
                    path: r.data.content?.path,
                }));
            }).catch((error) => {
                throw error;
            });
        }, interval);
        return this.intervalId;
    }

    private async syncMap() {
        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 false;
            this.map = map;
        }

        return true;
    }

    private async saveToGitHub(options: StoreOptions) {
        try {
            if (!options || !options.token) {
                throw new Error("GITHUB_TOKEN is needed");
            }
            const opt = {
                token: options.token,
                owner: options.owner,
                repo: options.repo,
                path: options.path,
                branch: options.branch,
                content: JSON.stringify(mapToRecord(this.map)),
            };
            return await uploadFileToGitHub(opt);
        } 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]) => {
        const entry = value as { value: V; expiry: number };
        map.set(key as K, entry);
    });

    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: StoreOptions): Promise<string | undefined> {
    if (!options || !options.token) throw new Error("GITHUB_TOKEN is needed");
    const octokit = new Octokit({ auth: options.token });
    try {
        const response = await octokit.repos.getContent({
            owner: options.owner,
            repo: options.repo,
            path: options.path,
            ref: options.branch,
        }) as any;

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

async function uploadFileToGitHub(
    options: {
        token?: string;
        owner: string;
        repo: string;
        path: string;
        content: string;
        branch?: string;
    },
) {
    const octokit = new Octokit({ auth: options.token });
    try {
        const res = await getFileFromGithub(options);
        const sha = res ? await getSHA(options) : undefined;
        const message = res
            ? `Update ${options.path}`
            : `Create ${options.path}`;
        return await octokit.repos.createOrUpdateFileContents({
            owner: options.owner,
            repo: options.repo,
            path: options.path,
            message,
            content: btoa(options.content),
            sha,
            branch: options.branch,
        });
    } catch (error) {
        throw error;
    }
}

async function getMap<K extends string | number | symbol, V>(
    options: StoreOptions,
) {
    if (!options || !options.token) return;
    const res = await getFileFromGithub(options) as any;
    if (res) return recordToMap<K, V>(JSON.parse(res));
}

/**
 * Gets the contents of a file in a repository (1-100 MB)
 */
async function getFileFromGithub(options: StoreOptions) {
    if (!options || !options.token) throw new Error("GITHUB_TOKEN is needed");
    const octokit = new Octokit({ auth: options.token });
    try {
        const res = await octokit.repos.getContent({
            owner: options.owner,
            repo: options.repo,
            path: options.path,
            ref: options.branch,
            mediaType: { format: "raw" },
        });
        return res.data;
    } catch {
        return undefined;
    }
}

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

fastrodev / fastro / 11070187911

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