11639349697

Committed 02 Nov 2024 03:03AM UTC coverage: 79.799% (+0.001%) from 79.798%

Build # 11639349697

Build Type

push

github

Committed by

ynwd

Commit Message

chore: update map/mod.ts

Run Details

129 of 186 branches covered (69.35%)

Branch coverage included in aggregate %.

4 of 5 new or added lines in 1 file covered. (80.0%)

1 existing line in 1 file now uncovered.

1376 of 1700 relevant lines covered (80.94%)

18.91 hits per line

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

89.5

/core/map/mod.ts

import {
    deleteGithubFile,
    getMap,
    mapToRecord,
    type StoreOptions,
    uploadFileToGitHub,
} from "../../utils/octokit.ts";
import { createTaskQueue } from "../../utils/queue.ts";

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 taskQueue = createTaskQueue();

    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 with queue
     */
    commit = async () => {
        return await this.taskQueue.process(this.commiting, this.options);
    };

    private commiting = async (options?: StoreOptions) => {
        if (!options) return;
        this.cleanUpExpiredEntries();
        return await this.saveToGitHub(
            {
                token: options?.token,
                owner: options.owner,
                repo: options.repo,
                path: options.path,
                branch: 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.map.size === 0) return;
            this.taskQueue.process(this.commiting, this.options);
        }, interval);
        return this.intervalId;
    }

    /**
     * Delete file from repository
     */
    async destroy() {
        try {
            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,
            });
        } catch (error) {
            throw error;
        }
    }

    public 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;
            this.cleanUpExpiredEntries();
            await this.commit();
        }

        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 {
        let count = 0;
        for (const [key, entry] of this.map.entries()) {
            if (entry.expiry !== undefined && Date.now() >= entry.expiry) {
                this.map.delete(key);
                count++;
            }
        }
        console.log(`${count} entries deleted`);
    }
}

1	import {	2✔
2	deleteGithubFile,	2✔
3	getMap,	2✔
4	mapToRecord,	2✔
5	type StoreOptions,
6	uploadFileToGitHub,	2✔
7	} from "../../utils/octokit.ts";	2✔
8	import { createTaskQueue } from "../../utils/queue.ts";	2✔
9
10	export class Store<K extends string \| number \| symbol, V> {	2✔
11	private map: Map<K, { value: V; expiry?: number }>;	2✔
12	private options: StoreOptions;	21✔
13	private intervalId: number \| null = null;	21✔
14	private taskQueue = createTaskQueue();	21✔
15
16	constructor(options: StoreOptions = null) {	21✔
17	this.map = new Map<K, { value: V; expiry?: number }>();	40✔
18	this.options = options;	40✔
19	}	40✔
20
21	/**	21✔
22	* 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.
23	* @param key
24	* @param value
25	* @param ttl
26	*/	21✔
27	set(key: K, value: V, ttl?: number) {	21✔
28	const expiry = ttl ? Date.now() + ttl : undefined;	45✔
29	this.map.set(key, { value, expiry });	180✔
30	return this;	45✔
31	}	45✔
32
33	/**	21✔
34	* @param key
35	* @returns boolean indicating whether an element with the specified key exists or not.
36	*/	21✔
37	check(key: K) {	21✔
38	if (this.map.has(key)) {	22✔
39	throw new Error(`Key ${String(key)} is already used`);	22✔
40	}	22!
41
42	return this;	×
43	}	×
44
45	/**	21✔
46	* 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.
47	* @returns - Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
48	*/	21✔
49	async get(key: K) {	21✔
50	await this.syncMap();	30✔
51	const entry = this.map.get(key);	30✔
52	if (entry) {	30✔
53	if (entry.expiry === undefined \|\| Date.now() < entry.expiry) {	38✔
54	return entry.value;	45✔
55	} else {	38✔
56	this.map.delete(key);	39✔
57	}	39✔
58	}	38✔
59	return undefined;	32✔
60	}	30✔
61
62	/**	21✔
63	* @param key
64	* @returns boolean indicating whether an element with the specified key exists or not.
65	*/	21✔
66	async has(key: K) {	21✔
67	await this.syncMap();	24✔
68	const entry = this.map.get(key);	24✔
69	if (entry) {	24✔
70	if (entry.expiry === undefined \|\| Date.now() < entry.expiry) {	26✔
71	return true;	27✔
72	} else {	27✔
73	this.map.delete(key);	27✔
74	}	27✔
75	}	26✔
76	return false;	26✔
77	}	24✔
78
79	/**	21✔
80	* @param key
81	* @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
82	*/	21✔
83	delete(key: K): boolean {	21✔
84	return this.map.delete(key);	22✔
85	}	22✔
86
87	clear(): void {	21✔
88	this.map.clear();	22✔
89	}	22✔
90
91	/**	21✔
92	* @returns the number of elements in the Map.
93	*/	21✔
94	size(): number {	21✔
95	this.cleanUpExpiredEntries();	24✔
96	return this.map.size;	24✔
97	}	24✔
98
99	/**	21✔
100	* @returns an iterable of key, value pairs for every entry in the map.
101	*/	21✔
102	entries() {	21✔
103	this.cleanUpExpiredEntries();	22✔
104	return this.map.entries();	22✔
105	}	22✔
106
107	/**	21✔
108	* @returns an iterable of values in the map
109	*/	21✔
110	values() {	21✔
111	this.cleanUpExpiredEntries();	22✔
112	return this.map.values();	22✔
113	}	22✔
114
115	/**	21✔
116	* @returns an iterable of keys in the map
117	*/	21✔
118	keys() {	21✔
119	this.cleanUpExpiredEntries();	22✔
120	return this.map.keys();	22✔
121	}	22✔
122
123	/**	21✔
124	* Executes a provided function once per each key/value pair in the Map, in insertion order.
125	* @param callback
126	*/	21✔
127	forEach(callback: (value: V, key: K) => void): void {	21✔
128	this.cleanUpExpiredEntries();	22✔
129	this.map.forEach((entry, key) => {	22✔
130	callback(entry.value, key);	25✔
131	});	22✔
132	}	22✔
133
134	/**	21✔
135	* Save to github with queue
136	*/	21✔
137	commit = async () => {	21✔
138	return await this.taskQueue.process(this.commiting, this.options);	29✔
139	};	21✔
140
141	private commiting = async (options?: StoreOptions) => {	21✔
142	if (!options) return;	30✔
143	this.cleanUpExpiredEntries();	38✔
144	return await this.saveToGitHub(	38✔
145	{	38✔
146	token: options?.token,	30✔
147	owner: options.owner,	30✔
148	repo: options.repo,	30✔
149	path: options.path,	30✔
150	branch: options?.branch,	30✔
151	},	30✔
152	);
153	};	2✔
154
155	/**	2✔
156	* Save the map to the repository periodically at intervals
157	* @param interval
158	* @returns intervalId
159	*/	2✔
160	sync(interval: number = 5000) {	2✔
161	if (this.intervalId) clearInterval(this.intervalId);	×
162	this.intervalId = setInterval(() => {	3✔
163	if (this.map.size === 0) return;	×
164	this.taskQueue.process(this.commiting, this.options);	4✔
165	}, interval);	3✔
166	return this.intervalId;	3✔
167	}	3✔
168
169	/**	2✔
170	* Delete file from repository
171	*/	2✔
172	async destroy() {	2✔
173	try {	4✔
174	if (!this.options) {	4✔
175	throw new Error("Options are needed to destroy.");	5✔
176	}	5✔
177	if (this.intervalId) clearInterval(this.intervalId);	×
178	this.map.clear();	5✔
179	return await deleteGithubFile({	5✔
180	token: this.options.token,	5✔
181	owner: this.options.owner,	5✔
182	repo: this.options.repo,	5✔
183	path: this.options.path,	5✔
184	branch: this.options.branch,	5✔
185	});	5✔
186	} catch (error) {	5✔
187	throw error;	5✔
188	}	5✔
189	}	4✔
190
191	public async syncMap() {	2✔
192	if (this.map.size === 0 && this.options) {	14✔
193	const map = await getMap<K, V>({	16✔
194	token: this.options.token,	16✔
195	owner: this.options.owner,	16✔
196	repo: this.options.repo,	16✔
197	path: this.options.path,	16✔
198	branch: this.options.branch,	16✔
199	});	16✔
200	if (!map) return false;	16✔
201	this.map = map;	17✔
202	this.cleanUpExpiredEntries();	17✔
203	await this.commit();	17✔
204	}	17✔
205
206	return true;	25✔
207	}	14✔
208
209	private async saveToGitHub(options: StoreOptions) {	2✔
210	try {	10✔
211	if (!options \|\| !options.token) {	×
212	throw new Error("GITHUB_TOKEN is needed");	×
213	}	×
214	const opt = {	10✔
215	token: options.token,	10✔
216	owner: options.owner,	10✔
217	repo: options.repo,	10✔
218	path: options.path,	10✔
219	branch: options.branch,	10✔
220	content: JSON.stringify(mapToRecord(this.map)),	10✔
221	};	10✔
222	return await uploadFileToGitHub(opt);	10✔
223	} catch (error) {	×
224	throw error;	×
225	}	×
226	}	10✔
227
228	private cleanUpExpiredEntries(): void {	2✔
229	let count = 0;	18✔
230	for (const [key, entry] of this.map.entries()) {	18✔
231	if (entry.expiry !== undefined && Date.now() >= entry.expiry) {	×
232	this.map.delete(key);	×
NEW 233	count++;	×
UNCOV 234	}	×
235	}	42✔
236	console.log(`${count} entries deleted`);	18✔
237	}	18✔
238	}	2✔

fastrodev / fastro / 11639349697

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