6567851021

Committed 18 Oct 2023 11:44PM UTC coverage: 84.987% (+0.01%) from 84.974%

Build # 6567851021

Build Type

Pull #36

github

Committed by

web-flow

Commit Message

Merge f29b9a5f6 into 45fc4b056

Pull Request Pull Request #36: Setup StandardJS tool in the project as static analysis tool

Run Details

10230 of 13274 branches covered (0.0%)

Branch coverage included in aggregate %.

170 of 195 new or added lines in 105 files covered. (87.18%)

4 existing lines in 3 files now uncovered.

22615 of 25373 relevant lines covered (89.13%)

3126.1 hits per line

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

81.48

/src/database/postgres/main.js

'use strict';

module.exports = function (module) {
    const helpers = require('./helpers');

    module.flushdb = async function () {
        await module.pool.query('DROP SCHEMA "public" CASCADE');
        await module.pool.query('CREATE SCHEMA "public"');
    };

    module.emptydb = async function () {
        await module.pool.query('DELETE FROM "legacy_object"');
    };

    module.exists = async function (key) {
        if (!key) {
            return;
        }

        // Redis/Mongo consider empty zsets as non-existent, match that behaviour
        const type = await module.type(key);
        if (type === 'zset') {
            if (Array.isArray(key)) {
                const members = await Promise.all(key.map(key => module.getSortedSetRange(key, 0, 0)));
                return members.map(member => member.length > 0);
            }
            const members = await module.getSortedSetRange(key, 0, 0);
            return members.length > 0;
        }

        if (Array.isArray(key)) {
            const res = await module.pool.query({
                name: 'existsArray',
                text: `
                SELECT o."_key" k
                  FROM "legacy_object_live" o
                 WHERE o."_key" = ANY($1::TEXT[])`,
                values: [key],
            });
            return key.map(k => res.rows.some(r => r.k === k));
        }
        const res = await module.pool.query({
            name: 'exists',
            text: `
            SELECT EXISTS(SELECT *
                    FROM "legacy_object_live"
                   WHERE "_key" = $1::TEXT
                   LIMIT 1) e`,
            values: [key],
        });
        return res.rows[0].e;
    };

    module.scan = async function (params) {
        let { match } = params;
        if (match.startsWith('*')) {
            match = `%${match.substring(1)}`;
        }
        if (match.endsWith('*')) {
            match = `${match.substring(0, match.length - 1)}%`;
        }

        const res = await module.pool.query({
            text: `
        SELECT o."_key"
        FROM "legacy_object_live" o
        WHERE o."_key" LIKE '${match}'`,
        });

        return res.rows.map(r => r._key);
    };

    module.delete = async function (key) {
        if (!key) {
            return;
        }

        await module.pool.query({
            name: 'delete',
            text: `
DELETE FROM "legacy_object"
 WHERE "_key" = $1::TEXT`,
            values: [key],
        });
    };

    module.deleteAll = async function (keys) {
        if (!Array.isArray(keys) || !keys.length) {
            return;
        }

        await module.pool.query({
            name: 'deleteAll',
            text: `
DELETE FROM "legacy_object"
 WHERE "_key" = ANY($1::TEXT[])`,
            values: [keys],
        });
    };

    module.get = async function (key) {
        if (!key) {
            return;
        }

        const res = await module.pool.query({
            name: 'get',
            text: `
SELECT s."data" t
  FROM "legacy_object_live" o
 INNER JOIN "legacy_string" s
         ON o."_key" = s."_key"
        AND o."type" = s."type"
 WHERE o."_key" = $1::TEXT
 LIMIT 1`,
            values: [key],
        });

        return res.rows.length ? res.rows[0].t : null;
    };

    module.set = async function (key, value) {
        if (!key) {
            return;
        }

        await module.transaction(async (client) => {
            await helpers.ensureLegacyObjectType(client, key, 'string');
            await client.query({
                name: 'set',
                text: `
INSERT INTO "legacy_string" ("_key", "data")
VALUES ($1::TEXT, $2::TEXT)
ON CONFLICT ("_key")
DO UPDATE SET "data" = $2::TEXT`,
                values: [key, value],
            });
        });
    };

    module.increment = async function (key) {
        if (!key) {
            return;
        }

        return await module.transaction(async (client) => {
            await helpers.ensureLegacyObjectType(client, key, 'string');
            const res = await client.query({
                name: 'increment',
                text: `
INSERT INTO "legacy_string" ("_key", "data")
VALUES ($1::TEXT, '1')
ON CONFLICT ("_key")
DO UPDATE SET "data" = ("legacy_string"."data"::NUMERIC + 1)::TEXT
RETURNING "data" d`,
                values: [key],
            });
            return parseFloat(res.rows[0].d);
        });
    };

    module.rename = async function (oldKey, newKey) {
        await module.transaction(async (client) => {
            await client.query({
                name: 'deleteRename',
                text: `
    DELETE FROM "legacy_object"
     WHERE "_key" = $1::TEXT`,
                values: [newKey],
            });
            await client.query({
                name: 'rename',
                text: `
UPDATE "legacy_object"
SET "_key" = $2::TEXT
WHERE "_key" = $1::TEXT`,
                values: [oldKey, newKey],
            });
        });
    };

    module.type = async function (key) {
        const res = await module.pool.query({
            name: 'type',
            text: `
SELECT "type"::TEXT t
  FROM "legacy_object_live"
 WHERE "_key" = $1::TEXT
 LIMIT 1`,
            values: [key],
        });

        return res.rows.length ? res.rows[0].t : null;
    };

    async function doExpire(key, date) {
        await module.pool.query({
            name: 'expire',
            text: `
UPDATE "legacy_object"
   SET "expireAt" = $2::TIMESTAMPTZ
 WHERE "_key" = $1::TEXT`,
            values: [key, date],
        });
    }

    module.expire = async function (key, seconds) {
        await doExpire(key, new Date(((Date.now() / 1000) + seconds) * 1000));
    };

    module.expireAt = async function (key, timestamp) {
        await doExpire(key, new Date(timestamp * 1000));
    };

    module.pexpire = async function (key, ms) {
        await doExpire(key, new Date(Date.now() + parseInt(ms, 10)));
    };

    module.pexpireAt = async function (key, timestamp) {
        await doExpire(key, new Date(timestamp));
    };

    async function getExpire(key) {
        const res = await module.pool.query({
            name: 'ttl',
            text: `
SELECT "expireAt"::TEXT
  FROM "legacy_object"
 WHERE "_key" = $1::TEXT
 LIMIT 1`,
            values: [key],
        });

        return res.rows.length ? new Date(res.rows[0].expireAt).getTime() : null;
    }

    module.ttl = async function (key) {
        return Math.round((await getExpire(key) - Date.now()) / 1000);
    };

    module.pttl = async function (key) {
        return await getExpire(key) - Date.now();
    };
};

1	'use strict';
2
3	module.exports = function (module) {	5✔
4	const helpers = require('./helpers');	5✔
5
6	module.flushdb = async function () {	5✔
NEW 7	await module.pool.query('DROP SCHEMA "public" CASCADE');	×
NEW 8	await module.pool.query('CREATE SCHEMA "public"');	×
9	};
10
11	module.emptydb = async function () {	5✔
12	await module.pool.query('DELETE FROM "legacy_object"');	48✔
13	};
14
15	module.exists = async function (key) {	5✔
16	if (!key) {	1,088!
17	return;	×
18	}
19
20	// Redis/Mongo consider empty zsets as non-existent, match that behaviour
21	const type = await module.type(key);	1,088✔
22	if (type === 'zset') {	1,088✔
23	if (Array.isArray(key)) {	106!
24	const members = await Promise.all(key.map(key => module.getSortedSetRange(key, 0, 0)));	×
25	return members.map(member => member.length > 0);	×
26	}
27	const members = await module.getSortedSetRange(key, 0, 0);	106✔
28	return members.length > 0;	106✔
29	}
30
31	if (Array.isArray(key)) {	982✔
32	const res = await module.pool.query({	310✔
33	name: 'existsArray',
34	text: `
35	SELECT o."_key" k
36	FROM "legacy_object_live" o
37	WHERE o."_key" = ANY($1::TEXT[])`,
38	values: [key],
39	});
40	return key.map(k => res.rows.some(r => r.k === k));	310✔
41	}
42	const res = await module.pool.query({	672✔
43	name: 'exists',
44	text: `
45	SELECT EXISTS(SELECT *
46	FROM "legacy_object_live"
47	WHERE "_key" = $1::TEXT
48	LIMIT 1) e`,
49	values: [key],
50	});
51	return res.rows[0].e;	672✔
52	};
53
54	module.scan = async function (params) {	5✔
55	let { match } = params;	2✔
56	if (match.startsWith('*')) {	2!
57	match = `%${match.substring(1)}`;	×
58	}
59	if (match.endsWith('*')) {	2!
60	match = `${match.substring(0, match.length - 1)}%`;	2✔
61	}
62
63	const res = await module.pool.query({	2✔
64	text: `
65	SELECT o."_key"
66	FROM "legacy_object_live" o
67	WHERE o."_key" LIKE '${match}'`,
68	});
69
70	return res.rows.map(r => r._key);	4✔
71	};
72
73	module.delete = async function (key) {	5✔
74	if (!key) {	438!
75	return;	×
76	}
77
78	await module.pool.query({	438✔
79	name: 'delete',
80	text: `
81	DELETE FROM "legacy_object"
82	WHERE "_key" = $1::TEXT`,
83	values: [key],
84	});
85	};
86
87	module.deleteAll = async function (keys) {	5✔
88	if (!Array.isArray(keys) \|\| !keys.length) {	323✔
89	return;	19✔
90	}
91
92	await module.pool.query({	304✔
93	name: 'deleteAll',
94	text: `
95	DELETE FROM "legacy_object"
96	WHERE "_key" = ANY($1::TEXT[])`,
97	values: [keys],
98	});
99	};
100
101	module.get = async function (key) {	5✔
102	if (!key) {	264!
103	return;	×
104	}
105
106	const res = await module.pool.query({	264✔
107	name: 'get',
108	text: `
109	SELECT s."data" t
110	FROM "legacy_object_live" o
111	INNER JOIN "legacy_string" s
112	ON o."_key" = s."_key"
113	AND o."type" = s."type"
114	WHERE o."_key" = $1::TEXT
115	LIMIT 1`,
116	values: [key],
117	});
118
119	return res.rows.length ? res.rows[0].t : null;	264✔
120	};
121
122	module.set = async function (key, value) {	5✔
123	if (!key) {	105!
124	return;	×
125	}
126
127	await module.transaction(async (client) => {	105✔
128	await helpers.ensureLegacyObjectType(client, key, 'string');	105✔
129	await client.query({	105✔
130	name: 'set',
131	text: `
132	INSERT INTO "legacy_string" ("_key", "data")
133	VALUES ($1::TEXT, $2::TEXT)
134	ON CONFLICT ("_key")
135	DO UPDATE SET "data" = $2::TEXT`,
136	values: [key, value],
137	});
138	});
139	};
140
141	module.increment = async function (key) {	5✔
142	if (!key) {	86!
143	return;	×
144	}
145
146	return await module.transaction(async (client) => {	86✔
147	await helpers.ensureLegacyObjectType(client, key, 'string');	86✔
148	const res = await client.query({	86✔
149	name: 'increment',
150	text: `
151	INSERT INTO "legacy_string" ("_key", "data")
152	VALUES ($1::TEXT, '1')
153	ON CONFLICT ("_key")
154	DO UPDATE SET "data" = ("legacy_string"."data"::NUMERIC + 1)::TEXT
155	RETURNING "data" d`,
156	values: [key],
157	});
158	return parseFloat(res.rows[0].d);	86✔
159	});
160	};
161
162	module.rename = async function (oldKey, newKey) {	5✔
163	await module.transaction(async (client) => {	21✔
164	await client.query({	21✔
165	name: 'deleteRename',
166	text: `
167	DELETE FROM "legacy_object"
168	WHERE "_key" = $1::TEXT`,
169	values: [newKey],
170	});
171	await client.query({	21✔
172	name: 'rename',
173	text: `
174	UPDATE "legacy_object"
175	SET "_key" = $2::TEXT
176	WHERE "_key" = $1::TEXT`,
177	values: [oldKey, newKey],
178	});
179	});
180	};
181
182	module.type = async function (key) {	5✔
183	const res = await module.pool.query({	1,094✔
184	name: 'type',
185	text: `
186	SELECT "type"::TEXT t
187	FROM "legacy_object_live"
188	WHERE "_key" = $1::TEXT
189	LIMIT 1`,
190	values: [key],
191	});
192
193	return res.rows.length ? res.rows[0].t : null;	1,094✔
194	};
195
196	async function doExpire(key, date) {
197	await module.pool.query({	214✔
198	name: 'expire',
199	text: `
200	UPDATE "legacy_object"
201	SET "expireAt" = $2::TIMESTAMPTZ
202	WHERE "_key" = $1::TEXT`,
203	values: [key, date],
204	});
205	}
206
207	module.expire = async function (key, seconds) {	5✔
208	await doExpire(key, new Date(((Date.now() / 1000) + seconds) * 1000));	1✔
209	};
210
211	module.expireAt = async function (key, timestamp) {	5✔
212	await doExpire(key, new Date(timestamp * 1000));	×
213	};
214
215	module.pexpire = async function (key, ms) {	5✔
216	await doExpire(key, new Date(Date.now() + parseInt(ms, 10)));	203✔
217	};
218
219	module.pexpireAt = async function (key, timestamp) {	5✔
220	await doExpire(key, new Date(timestamp));	10✔
221	};
222
223	async function getExpire(key) {
224	const res = await module.pool.query({	5✔
225	name: 'ttl',
226	text: `
227	SELECT "expireAt"::TEXT
228	FROM "legacy_object"
229	WHERE "_key" = $1::TEXT
230	LIMIT 1`,
231	values: [key],
232	});
233
234	return res.rows.length ? new Date(res.rows[0].expireAt).getTime() : null;	5!
235	}
236
237	module.ttl = async function (key) {	5✔
238	return Math.round((await getExpire(key) - Date.now()) / 1000);	1✔
239	};
240
241	module.pttl = async function (key) {	5✔
242	return await getExpire(key) - Date.now();	4✔
243	};
244	};

CMU-17313Q / fall23-nodebb-generation-z / 6567851021

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