10730324367

Committed 06 Sep 2024 12:35AM UTC coverage: 77.949% (+2.7%) from 75.24%

Build # 10730324367

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #430 from fastrodev/dev

Dev

Run Details

98 of 137 branches covered (71.53%)

Branch coverage included in aggregate %.

238 of 262 new or added lines in 8 files covered. (90.84%)

1 existing line in 1 file now uncovered.

1065 of 1355 relevant lines covered (78.6%)

17.6 hits per line

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

91.89

/modules/group/group.service.ts

import { kv } from "@app/utils/db.ts";
import { GroupArgType, GroupType } from "@app/modules/group/group.type.ts";
import { ulid } from "jsr:@std/ulid";
import { combineObjects } from "@app/utils/general.ts";

export async function createGroup(group: GroupArgType) {
    const groupId = ulid();
    const newGroup = {
        groupId,
        active: true,
    };
    const g = combineObjects(newGroup, group) as GroupType;
    const primaryKey = ["groups", groupId];
    const groupByNameKey = ["groups_by_name", group.name, groupId];

    const atomicOp = kv.atomic();
    atomicOp
        .check({ key: primaryKey, versionstamp: null })
        .set(primaryKey, g)
        .set(groupByNameKey, g);

    const res = await atomicOp.commit();
    if (!res.ok) throw new Error("Failed to create group");
    return g;
}

export async function updateGroup(group: GroupType) {
    if (!group.groupId) throw new Error("group.id must not be null");

    const atomicOp = kv.atomic();
    const groupKey = ["groups", group.groupId];

    const ug = await kv.get<GroupType>(groupKey);
    if (ug.value?.groupId) {
        atomicOp.check(ug)
            .delete(["groups_by_name", ug.value.name, ug.value.groupId])
            .set(["groups_by_name", group.name, group.groupId], group);
    }

    atomicOp.set(groupKey, group);

    const res = await atomicOp.commit();
    if (!res.ok) throw new Error("Failed to create group");

    const g = await kv.get<GroupType>(groupKey);
    return g.value;
}

export async function getGroup(groupId: string): Promise<GroupType | null> {
    const res = await kv.get<GroupType>(["groups", groupId]);
    return res.value;
}

export function listGroups(
    options?: Deno.KvListOptions,
) {
    return kv.list<GroupType>({ prefix: ["groups"] }, options);
}

export function listGroupsByName(
    name?: string,
    options?: Deno.KvListOptions,
) {
    if (name) {
        return kv.list<GroupType>(
            { prefix: ["groups_by_name", name] },
            options,
        );
    }
    return kv.list<GroupType>({ prefix: ["groups_by_name"] }, options);
}

export async function deleteGroup(id: string) {
    let res = { ok: false };
    while (!res.ok) {
        const getRes = await kv.get<GroupType>(["groups", id]);
        if (getRes && getRes.value) {
            res = await kv.atomic()
                .check(getRes)
                .delete(["groups", id])
                .delete(["groups_by_name", getRes.value.name, id])
                .commit();
        }
    }
    return res;
}

1	import { kv } from "@app/utils/db.ts";	2✔
2	import { GroupArgType, GroupType } from "@app/modules/group/group.type.ts";
3	import { ulid } from "jsr:@std/ulid";	2✔
4	import { combineObjects } from "@app/utils/general.ts";	2✔
5
6	export async function createGroup(group: GroupArgType) {	2✔
7	const groupId = ulid();	5✔
8	const newGroup = {	5✔
9	groupId,	5✔
10	active: true,	5✔
11	};	5✔
12	const g = combineObjects(newGroup, group) as GroupType;	5✔
13	const primaryKey = ["groups", groupId];	20✔
14	const groupByNameKey = ["groups_by_name", group.name, groupId];	25✔
15
16	const atomicOp = kv.atomic();	5✔
17	atomicOp	5✔
18	.check({ key: primaryKey, versionstamp: null })	20✔
19	.set(primaryKey, g)	5✔
20	.set(groupByNameKey, g);	5✔
21
22	const res = await atomicOp.commit();	5✔
NEW 23	if (!res.ok) throw new Error("Failed to create group");	×
24	return g;	5✔
25	}	5✔
26
27	export async function updateGroup(group: GroupType) {	2✔
NEW 28	if (!group.groupId) throw new Error("group.id must not be null");	×
29
30	const atomicOp = kv.atomic();	3✔
31	const groupKey = ["groups", group.groupId];	12✔
32
33	const ug = await kv.get<GroupType>(groupKey);	3✔
34	if (ug.value?.groupId) {	3✔
35	atomicOp.check(ug)	3✔
36	.delete(["groups_by_name", ug.value.name, ug.value.groupId])	15✔
37	.set(["groups_by_name", group.name, group.groupId], group);	15✔
38	}	3✔
39
40	atomicOp.set(groupKey, group);	3✔
41
42	const res = await atomicOp.commit();	3✔
NEW 43	if (!res.ok) throw new Error("Failed to create group");	×
44
45	const g = await kv.get<GroupType>(groupKey);	3✔
46	return g.value;	3✔
47	}	3✔
48
49	export async function getGroup(groupId: string): Promise<GroupType \| null> {	2✔
50	const res = await kv.get<GroupType>(["groups", groupId]);	12✔
51	return res.value;	3✔
52	}	3✔
53
54	export function listGroups(	2✔
55	options?: Deno.KvListOptions,	2✔
56	) {
57	return kv.list<GroupType>({ prefix: ["groups"] }, options);	15✔
58	}	3✔
59
60	export function listGroupsByName(	2✔
61	name?: string,	2✔
62	options?: Deno.KvListOptions,	2✔
63	) {
64	if (name) {	5✔
65	return kv.list<GroupType>(	7✔
66	{ prefix: ["groups_by_name", name] },	42✔
67	options,	7✔
68	);
69	}	7✔
70	return kv.list<GroupType>({ prefix: ["groups_by_name"] }, options);	30✔
71	}	5✔
72
73	export async function deleteGroup(id: string) {	2✔
74	let res = { ok: false };	9✔
75	while (!res.ok) {	3✔
76	const getRes = await kv.get<GroupType>(["groups", id]);	12✔
77	if (getRes && getRes.value) {	3✔
78	res = await kv.atomic()	3✔
79	.check(getRes)	3✔
80	.delete(["groups", id])	12✔
81	.delete(["groups_by_name", getRes.value.name, id])	15✔
82	.commit();	3✔
83	}	3✔
84	}	3✔
85	return res;	3✔
86	}	3✔

fastrodev / fastro / 10730324367

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