probably I broke it

src/lib/db/entities/boardMessages.ts

@@ -1,8 +1,8 @@
-import { Ref, ref, watch } from "vue";
+import { Ref, shallowRef, watch } from "vue";
 import { db } from "..";
 import { makeUUIDv5 } from "../../util/uuid";
 import { UUID, UUIDable } from "../types";
-import { Member, members } from "./members";
+import { getMembersTable, Member } from "./members";
 import { getSystemUUID } from "./system";
 import { from, useObservable } from "@vueuse/rxjs";
 import { liveQuery } from "dexie";
@@ -16,23 +16,24 @@ export type BoardMessage = UUIDable & {
 
 export type BoardMessageComplete = Omit<BoardMessage, "member"> & { member: Member }
 
-export function getTable() {
+export function getBoardMessagesTable() {
 	return db.boardMessages;
 }
 
-export const boardMessages: Ref<BoardMessageComplete[]> = ref([]);
+export const boardMessages: Ref<BoardMessageComplete[]> = shallowRef([]);
 
 export async function updateBoardMessagesRef() {
-	const _boardMessages = await getTable().toArray();
-	boardMessages.value = _boardMessages.map(x => ({
-		...x,
-		member: members.value.find(y => y.uuid === x.member)!
-	}));
+	const boardMessagesComplete: BoardMessageComplete[] = [];
+	for (const boardMessage of await getBoardMessagesTable().toArray()) {
+		const member = (await getMembersTable().get(boardMessage.member))!
+		boardMessagesComplete.push({ ...boardMessage, member});
+	}
+	boardMessages.value = boardMessagesComplete;
 }
 
 watch([
-	useObservable(from(liveQuery(() => getTable().toArray()))),
-	members
+	useObservable(from(liveQuery(() => getBoardMessagesTable().toArray()))),
+	useObservable(from(liveQuery(() => getMembersTable().toArray()))),
 ], updateBoardMessagesRef, { immediate: true });
 
 
@@ -42,7 +43,7 @@ function genid(name: string) {
 
 export async function newBoardMessage(boardMessage: Omit<BoardMessage, keyof UUIDable>) {
 	const uuid = genid(boardMessage.title);
-	return await getTable().add({
+	return await getBoardMessagesTable().add({
 		...boardMessage,
 		uuid
 	});

src/lib/db/entities/chatMessages.ts

@@ -10,7 +10,7 @@ export type ChatMessage = UUIDable & {
 	message: string,
 }
 
-export function getTable() {
+export function getChatMessagesTable() {
 	return db.chatMessages;
 }
 
@@ -20,7 +20,7 @@ function genid(name: string) {
 
 export async function newChatMessage(chatMessage: Omit<ChatMessage, keyof UUIDable>) {
 	const uuid = genid(chatMessage.member + chatMessage.date.toTimeString());
-	return await getTable().add({
+	return await getChatMessagesTable().add({
 		...chatMessage,
 		uuid
 	});

src/lib/db/entities/chats.ts

@@ -8,7 +8,7 @@ export type Chat = UUIDable & {
 	image?: File
 }
 
-export function getTable(){
+export function getChatsTable(){
 	return db.chats;
 }
 
@@ -18,7 +18,7 @@ function genid(name: string) {
 
 export async function newChat(chat: Omit<Chat, keyof UUIDable>) {
 	const uuid = genid(chat.name);
-	return await getTable().add({
+	return await getChatsTable().add({
 		...chat,
 		uuid
 	});

src/lib/db/entities/frontingEntries.ts

@@ -1,11 +1,11 @@
-import { ref, Ref, watch } from "vue";
+import { Ref, shallowRef, watch } from "vue";
 import { db } from "..";
 import { makeUUIDv5 } from "../../util/uuid";
 import { UUID, UUIDable } from "../types";
 import { getSystemUUID } from "./system";
 import { from, useObservable } from "@vueuse/rxjs";
 import { liveQuery } from "dexie";
-import { Member, members } from "./members";
+import { getMembersTable, Member } from "./members";
 import { parseFrontingHistoryFilterQuery as parseFrontingEntriesFilterQuery } from "../../util/filterQuery";
 import dayjs from "dayjs";
 
@@ -19,23 +19,28 @@ export type FrontingEntry = UUIDable & {
 
 export type FrontingEntryComplete = Omit<FrontingEntry, "member"> & { member: Member }
 
-export function getTable(){
+export function getFrontingEntriesTable(){
 	return db.frontingEntries;
 }
 
-export const frontingEntries: Ref<FrontingEntryComplete[]> = ref([]);
+export async function toFrontingEntryComplete(frontingEntry: FrontingEntry): Promise<FrontingEntryComplete> {
+	const member = (await getMembersTable().get(frontingEntry.member))!;
+	return { ...frontingEntry, member };
+}
+
+export const frontingEntries: Ref<FrontingEntryComplete[]> = shallowRef([]);
 
 export async function updateFrontingEntriesRef() {
-	const _frontingEntries = await getTable().toArray();
-	frontingEntries.value = _frontingEntries.map(x => ({
-		...x,
-		member: members.value.find(y => y.uuid === x.member)!
-	}));
+	const frontingEntriesComplete: FrontingEntryComplete[] = [];
+	for (const frontingEntry of await getFrontingEntriesTable().toArray()) {
+		frontingEntriesComplete.push(await toFrontingEntryComplete(frontingEntry));
+	}
+	frontingEntries.value = frontingEntriesComplete;
 }
 
 watch([
-	useObservable(from(liveQuery(() => getTable().toArray()))),
-	members
+	useObservable(from(liveQuery(() => getFrontingEntriesTable().toArray()))),
+	useObservable(from(liveQuery(() => getMembersTable().toArray())))
 ], updateFrontingEntriesRef, { immediate: true });
 
 
@@ -45,46 +50,46 @@ function genid(name: string) {
 
 export async function newFrontingEntry(frontingEntry: Omit<FrontingEntry, keyof UUIDable>) {
 	const uuid = genid(frontingEntry.member + frontingEntry.startTime.getTime());
-	return await getTable().add({
+	return await getFrontingEntriesTable().add({
 		...frontingEntry,
 		uuid
 	});
 }
 
 export async function removeFronter(member: Member) {
-	const f = getCurrentFrontEntryForMember(member);
+	const f = await getCurrentFrontEntryForMember(member);
 	if(!f) return;
 
-	await getTable().update(f.uuid, {
+	await getFrontingEntriesTable().update(f.uuid, {
 		endTime: new Date()
 	});
 }
 
 export async function setMainFronter(member: Member, value: boolean){
-	const f = getCurrentFrontEntryForMember(member);
+	const f = await getCurrentFrontEntryForMember(member);
 	if (!f) return;
 
 	if(value){
-		const toUpdate = frontingEntries.value.filter(x => !x.endTime && x.member.uuid !== member.uuid).map(x => x.uuid);
+		const toUpdate = (await getFrontingEntriesTable().filter(x => !x.endTime && x.member !== member.uuid).toArray()).map(x => x.uuid);
 
 		for (const uuid of toUpdate) {
-			await getTable().update(uuid, {
+			await getFrontingEntriesTable().update(uuid, {
 				isMainFronter: false
 			});
 		}
 	}
 
-	await getTable().update(f.uuid, {
+	await getFrontingEntriesTable().update(f.uuid, {
 		isMainFronter: value
 	});
 }
 
 export async function setSoleFronter(member: Member) {
-	const toUpdate = frontingEntries.value.filter(x => !x.endTime && x.member.uuid !== member.uuid).map(x => x.uuid);
+	const toUpdate = (await getFrontingEntriesTable().filter(x => !x.endTime && x.member !== member.uuid).toArray()).map(x => x.uuid);
 	const endTime = new Date();
 
 	for(const uuid of toUpdate){
-		await getTable().update(uuid, {
+		await getFrontingEntriesTable().update(uuid, {
 			endTime
 		});
 	}
@@ -98,56 +103,68 @@ export async function setSoleFronter(member: Member) {
 	}
 }
 
-export function getCurrentFrontEntryForMember(member: Member){
-	return frontingEntries.value.find(x => {
-		return x.endTime === undefined && x.member.uuid === member.uuid
-	});
+export async function getCurrentFrontEntryForMember(member: Member){
+	return await getFrontingEntriesTable().filter(x => x.endTime === undefined && x.member === member.uuid).first();
 }
 
-export function getMainFronter(){
-	return frontingEntries.value.find(x => x.endTime === undefined && x.isMainFronter)?.member;
+export async function getMainFronter(){
+	const mainFronterEntry = await getFrontingEntriesTable().get({ endTime: undefined, isMainFronter: true });
+	if(mainFronterEntry){
+		return await getMembersTable().get(mainFronterEntry.member);
+	}
+	return undefined;
 }
 
-export function getFronting() {
-	return frontingEntries.value.filter(x => x.endTime === undefined).map(x => x.member);
+export async function getFronting() {
+	const frontersEntries = await getFrontingEntriesTable().filter(x => x.endTime === undefined).toArray();
+	const frontingMembers: Member[] = [];
+	for(const entry of frontersEntries){
+		const member = await getMembersTable().get(entry.member);
+		if(member)
+			frontingMembers.push(member);
+	}
+	return frontingMembers;
 }
 
-export function getFrontingEntriesFromFilterQuery(filterQuery: string) {
+export async function getFrontingEntriesFromFilterQuery(filterQuery: string) {
 	const parsed = parseFrontingEntriesFilterQuery(filterQuery);
 
-	console.log(parsed);
+	const filtered: FrontingEntryComplete[] = [];
 
-	return frontingEntries.value.filter(x => {
+	for(const x of await getFrontingEntriesTable().toArray()){
+			const complete = await toFrontingEntryComplete(x);
 
-		if (!x.member.name.startsWith(parsed.query))
-			return false;
+			if (!complete.member.name.startsWith(parsed.query))
+				continue;
 
-		if (parsed.currentlyFronting) {
-			if(x.endTime)
-				return false;
-		}
+			if (parsed.currentlyFronting) {
+				if (x.endTime)
+					continue;
+			}
 
-		if (parsed.dateString) {
-			const date = dayjs(parsed.dateString).startOf("day");
-			if (date.valueOf() !== dayjs(x.startTime).startOf("day").valueOf())
-				return false;
-		}
+			if (parsed.dateString) {
+				const date = dayjs(parsed.dateString).startOf("day");
+				if (date.valueOf() !== dayjs(x.startTime).startOf("day").valueOf())
+					continue;
+			}
 
-		if (parsed.day) {
-			if (parsed.day !== dayjs(x.startTime).get("date"))
-				return false;
-		}
+			if (parsed.day) {
+				if (parsed.day !== dayjs(x.startTime).get("date"))
+					continue;
+			}
 
-		if (parsed.month) {
-			if (parsed.month !== dayjs(x.startTime).get("month") + 1)
-				return false;
-		}
+			if (parsed.month) {
+				if (parsed.month !== dayjs(x.startTime).get("month") + 1)
+					continue;
+			}
 
-		if (parsed.year) {
-			if (parsed.year !== dayjs(x.startTime).get("year"))
-				return false;
-		}
+			if (parsed.year) {
+				if (parsed.year !== dayjs(x.startTime).get("year"))
+					continue;
+			}
 
-		return true;
-	});
+			filtered.push(complete)
+	}
+
+	return filtered;
 }

src/lib/db/entities/journalPosts.ts

@@ -18,7 +18,7 @@ export type Attachment = UUIDable & {
 	file: File
 }
 
-export function getTable() {
+export function getJournalPostsTable() {
 	return db.journalPosts;
 }
 
@@ -28,7 +28,7 @@ function genid(name: string) {
 
 export async function newJournalPost(journalPost: Omit<JournalPost, keyof UUIDable>) {
 	const uuid = genid(journalPost.member + journalPost.title);
-	return await getTable().add({
+	return await getJournalPostsTable().add({
 		...journalPost,
 		uuid
 	});

src/lib/db/entities/members.ts

@@ -1,4 +1,4 @@
-import { Ref, ref, watch } from "vue";
+import { shallowRef, watch } from "vue";
 import { db } from "..";
 import { parseMemberFilterQuery } from "../../util/filterQuery";
 import { makeUUIDv5 } from "../../util/uuid";
@@ -19,34 +19,34 @@ export type Member = UUIDable & {
 	tags: UUID[] // array of UUIDs
 }
 
-export function getTable() {
+export function getMembersTable() {
 	return db.members;
 }
 
-export const members: Ref<Member[]> = ref([]);
+export const members = shallowRef<Member[]>([]);
 
 export async function updateMembersRef(){
-	members.value = await getTable().toArray();
+	members.value = await getMembersTable().toArray();
 }
 
-watch([useObservable(from(liveQuery(() => getTable().toArray())))], updateMembersRef, { immediate: true });
+watch(useObservable(from(liveQuery(() => getMembersTable().toArray()))), updateMembersRef, { immediate: true });
 
 function genid(name: string) {
 	return makeUUIDv5(getSystemUUID(), `members\0${name}`);
 }
 
 export async function newMember(member: Omit<Member, keyof UUIDable>) {
 	const uuid = genid(member.name);
-	return await getTable().add({
+	return await getMembersTable().add({
 		...member,
 		uuid
 	});
 }
 
-export function getMembersFromFilterQuery(filterQuery: string) {
-	const parsed = parseMemberFilterQuery(filterQuery);
+export async function getMembersFromFilterQuery(filterQuery: string) {
+	const parsed = await parseMemberFilterQuery(filterQuery);
 
-	return getTable().where("name").startsWithIgnoreCase(parsed.query).filter(x => {
+	return getMembersTable().where("name").startsWithIgnoreCase(parsed.query).filter(x => {
 
 		if(parsed.pronouns){
 			if (!x.pronouns || x.pronouns.toLowerCase() !== parsed.pronouns.toLowerCase())

src/lib/db/entities/reminders.ts

@@ -32,7 +32,7 @@ export type PeriodicReminder = ReminderBase & {
 
 export type Reminder = EventReminder | PeriodicReminder;
 
-export function getTable() {
+export function getRemindersTable() {
 	return db.reminders;
 }
 
@@ -42,7 +42,7 @@ function genid(name: string) {
 
 export async function newReminder(reminder: Omit<Reminder, keyof UUIDable>) {
 	const uuid = genid(reminder.name);
-	return await getTable().add({
+	return await getRemindersTable().add({
 		...reminder,
 		uuid
 	});