@delta-comic/db 2.2.0 → 3.0.0-next.4

package/dist/index.mjs

@@ -0,0 +1,705 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { logger } from "@delta-comic/logger";
+import { isTauri } from "@tauri-apps/api/core";
+import { CamelCasePlugin, Kysely } from "kysely";
+import { SerializePlugin } from "kysely-plugin-serialize";
+import { defineMutation, useMutation, useQuery, useQueryCache } from "@pinia/colada";
+import { SourcedValue, Struct, uni } from "@delta-comic/model";
+import { fromPairs } from "es-toolkit/compat";
+import { ref, toValue, watch } from "vue";
+//#region lib/utils.ts
+var utils_exports = /* @__PURE__ */ __exportAll({
+	CommonQueryKey: () => CommonQueryKey,
+	countDb: () => countDb,
+	withTransition: () => withTransition
+});
+const transactionLogger = logger.scoped("db:transaction");
+const withTransition = async (handler, trx) => {
+	if (trx) return await handler(trx);
+	else {
+		const { db } = await import("./index.mjs");
+		transactionLogger.trace("database transaction started");
+		try {
+			const result = await db.transaction().setAccessMode("read write").setIsolationLevel("read committed").execute(handler);
+			transactionLogger.trace("database transaction committed");
+			return result;
+		} catch (error) {
+			transactionLogger.error("database transaction failed", error);
+			throw error;
+		}
+	}
+};
+async function countDb(sql) {
+	return (await sql.select((db) => db.fn.countAll().as("count")).executeTakeFirstOrThrow()).count;
+}
+let CommonQueryKey = /* @__PURE__ */ function(CommonQueryKey) {
+	CommonQueryKey["common"] = "db";
+	return CommonQueryKey;
+}({});
+//#endregion
+//#region lib/plugin.ts
+var plugin_exports = /* @__PURE__ */ __exportAll({
+	QueryKey: () => QueryKey$5,
+	removeByNames: () => removeByNames,
+	useQuery: () => useQuery$4,
+	useRemove: () => useRemove$3,
+	useSetKind: () => useSetKind,
+	useToggleEnable: () => useToggleEnable,
+	useUpsert: () => useUpsert$4
+});
+let QueryKey$5 = /* @__PURE__ */ function(QueryKey) {
+	QueryKey["item"] = "db:plugin:";
+	return QueryKey;
+}({});
+const removeByNames = async (keys, trx) => {
+	if (keys.length === 0) return;
+	await trx.deleteFrom("plugin").where("plugin.pluginName", "in", keys).execute();
+};
+const useUpsert$4 = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const key = ["db", "db:plugin:"];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ archives, trx }) => withTransition(async (trx) => {
+			await trx.replaceInto("plugin").values(archives.map((a) => ({
+				...a,
+				meta: JSON.stringify(a.meta)
+			}))).execute();
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		upsert: mutateAsync,
+		key
+	};
+});
+const useRemove$3 = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const key = ["db", "db:plugin:"];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ keys, trx }) => withTransition(async (trx) => {
+			await removeByNames(keys, trx);
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		remove: mutateAsync,
+		key
+	};
+});
+const useToggleEnable = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const key = ["db", "db:plugin:"];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ keys, trx }) => withTransition(async (trx) => {
+			for (const key of keys) {
+				const isEnable = await trx.selectFrom("plugin").where("pluginName", "=", key).select("enable").executeTakeFirstOrThrow();
+				return trx.updateTable("plugin").where("pluginName", "=", key).set({ enable: !isEnable.enable }).execute();
+			}
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		toggle: mutateAsync,
+		key
+	};
+});
+const useSetKind = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const key = ["db", "db:plugin:"];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ pluginName, kind }) => withTransition(async (trx) => {
+			const plugin = await trx.selectFrom("plugin").select(["loaderName", "meta"]).where("pluginName", "=", pluginName).executeTakeFirstOrThrow();
+			if (plugin.loaderName === "builtin") throw new Error("built-in plugin kind cannot be changed");
+			await trx.updateTable("plugin").set({ meta: JSON.stringify({
+				...plugin.meta,
+				kind
+			}) }).where("pluginName", "=", pluginName).execute();
+		}),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		setKind: mutateAsync,
+		key
+	};
+});
+const useQuery$4 = (query, otherKeys = [], initialData) => useQuery({
+	query: async () => {
+		const { db } = await import("./index.mjs");
+		return await query(db.selectFrom("plugin"));
+	},
+	key: () => [
+		"db",
+		"db:plugin:",
+		query
+	].concat(otherKeys),
+	staleTime: 15e3,
+	refetchOnMount: "always",
+	initialData,
+	initialDataUpdatedAt: 0
+});
+//#endregion
+//#region lib/itemStore.ts
+var itemStore_exports = /* @__PURE__ */ __exportAll({
+	QueryKey: () => QueryKey$4,
+	itemKey: () => itemKey,
+	useUpsert: () => useUpsert$3
+});
+const itemKey = new SourcedValue("*");
+let QueryKey$4 = /* @__PURE__ */ function(QueryKey) {
+	QueryKey["item"] = "db:itemStore:";
+	return QueryKey;
+}({});
+const useUpsert$3 = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const key = ["db", "db:itemStore:"];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ item, trx }) => withTransition(async (trx) => {
+			const k = itemKey.toString([uni.content.ContentPage.contentPages.key.toString(item.contentType), item.id]);
+			await trx.replaceInto("itemStore").values({
+				item: Struct.toRaw(item),
+				key: k
+			}).execute();
+			return k;
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		upsert: mutateAsync,
+		key
+	};
+});
+//#endregion
+//#region lib/favourite.ts
+var favourite_exports = /* @__PURE__ */ __exportAll({
+	QueryKey: () => QueryKey$3,
+	useCreateCard: () => useCreateCard,
+	useMoveItem: () => useMoveItem,
+	useQueryCard: () => useQueryCard,
+	useQueryItem: () => useQueryItem,
+	useUpsertItem: () => useUpsertItem
+});
+let QueryKey$3 = /* @__PURE__ */ function(QueryKey) {
+	QueryKey["item"] = "db:favouriteItem:";
+	QueryKey["card"] = "db:favouriteCard:";
+	return QueryKey;
+}({});
+const useUpsertItem = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const { key: iKey, upsert } = useUpsert$3();
+	const key = [
+		"db",
+		"db:favouriteItem:",
+		...iKey
+	];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ item, belongTos, trx }) => withTransition(async (trx) => {
+			const itemKey = await upsert({
+				item,
+				trx
+			});
+			await trx.replaceInto("favouriteItem").values(belongTos.map((belongTo) => ({
+				addTime: Date.now(),
+				itemKey,
+				belongTo
+			}))).execute();
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		upsert: mutateAsync,
+		key
+	};
+});
+const useMoveItem = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const key = ["db:favouriteItem:"];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ item, from, aims, trx }) => withTransition(async (trx) => {
+			await trx.deleteFrom("favouriteItem").where("itemKey", "=", item.id).where("belongTo", "=", from).execute();
+			await trx.replaceInto("favouriteItem").values(aims.map((to) => ({
+				addTime: Date.now(),
+				itemKey: item.id,
+				belongTo: to
+			}))).execute();
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		move: mutateAsync,
+		key
+	};
+});
+const useCreateCard = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const key = ["db:favouriteCard:", "db:favouriteItem:"];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ card, trx }) => withTransition(async (trx) => {
+			await trx.replaceInto("favouriteCard").values(card).execute();
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		createCard: mutateAsync,
+		key
+	};
+});
+const useQueryItem = (query, otherKeys = [], initialData) => useQuery({
+	query: async () => {
+		const { db } = await import("./index.mjs");
+		return await query(db.selectFrom("favouriteItem"));
+	},
+	key: () => [
+		"db:favouriteItem:",
+		"db:favouriteCard:",
+		query
+	].concat(otherKeys),
+	staleTime: 15e3,
+	initialData,
+	initialDataUpdatedAt: 0
+});
+const useQueryCard = (query, otherKeys = [], initialData) => useQuery({
+	query: async () => {
+		const { db } = await import("./index.mjs");
+		return await query(db.selectFrom("favouriteCard"));
+	},
+	key: () => ["db:favouriteCard:", query].concat(otherKeys),
+	staleTime: 15e3,
+	refetchOnMount: "always",
+	initialData,
+	initialDataUpdatedAt: 0
+});
+//#endregion
+//#region lib/history.ts
+var history_exports = /* @__PURE__ */ __exportAll({
+	QueryKey: () => QueryKey$2,
+	useQuery: () => useQuery$3,
+	useRemove: () => useRemove$2,
+	useUpsert: () => useUpsert$2
+});
+let QueryKey$2 = /* @__PURE__ */ function(QueryKey) {
+	QueryKey["item"] = "db:history:";
+	return QueryKey;
+}({});
+const useUpsert$2 = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const { key: iKey, upsert } = useUpsert$3();
+	const key = [
+		"db",
+		"db:history:",
+		...iKey
+	];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ item, trx }) => withTransition(async (trx) => {
+			const itemKey = await upsert({
+				item,
+				trx
+			});
+			await trx.replaceInto("history").values({
+				itemKey,
+				timestamp: Date.now(),
+				ep: Struct.toRaw(item)
+			}).execute();
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		upsert: mutateAsync,
+		key
+	};
+});
+const useRemove$2 = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const key = ["db", "db:history:"];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: ({ keys, trx }) => withTransition(async (trx) => {
+			await trx.deleteFrom("history").where("history.timestamp", "is", keys).execute();
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		remove: mutateAsync,
+		key
+	};
+});
+const useQuery$3 = (query, otherKeys = [], initialData) => useQuery({
+	query: async () => {
+		const { db } = await import("./index.mjs");
+		return await query(db.selectFrom("history"));
+	},
+	key: () => [
+		"db",
+		"db:history:",
+		query
+	].concat(otherKeys),
+	staleTime: 15e3,
+	refetchOnMount: "always",
+	initialData,
+	initialDataUpdatedAt: 0
+});
+//#endregion
+//#region lib/subscribe.ts
+var subscribe_exports = /* @__PURE__ */ __exportAll({
+	QueryKey: () => QueryKey$1,
+	key: () => key,
+	useQuery: () => useQuery$2,
+	useRemove: () => useRemove$1,
+	useUpsert: () => useUpsert$1
+});
+const key = new SourcedValue();
+let QueryKey$1 = /* @__PURE__ */ function(QueryKey) {
+	QueryKey["item"] = "db:subscribe:";
+	return QueryKey;
+}({});
+const useUpsert$1 = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const key = ["db", "db:subscribe:"];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ items, trx }) => withTransition(async (trx) => {
+			await trx.replaceInto("subscribe").values(items.map((item) => ({
+				...item,
+				author: JSON.stringify(item.author)
+			}))).execute();
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		upsert: mutateAsync,
+		key
+	};
+});
+const useRemove$1 = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const key = ["db", "db:subscribe:"];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ keys, trx }) => withTransition(async (trx) => {
+			await trx.deleteFrom("subscribe").where("subscribe.key", "is", keys).execute();
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		remove: mutateAsync,
+		key
+	};
+});
+const useQuery$2 = (query, otherKeys = [], initialData) => useQuery({
+	query: async () => {
+		const { db } = await import("./index.mjs");
+		return await query(db.selectFrom("subscribe"));
+	},
+	key: () => [
+		"db",
+		"db:subscribe:",
+		query
+	].concat(otherKeys),
+	staleTime: 15e3,
+	refetchOnMount: "always",
+	initialData,
+	initialDataUpdatedAt: 0
+});
+//#endregion
+//#region lib/recentView.ts
+var recentView_exports = /* @__PURE__ */ __exportAll({
+	QueryKey: () => QueryKey,
+	useQuery: () => useQuery$1,
+	useRemove: () => useRemove,
+	useUpsert: () => useUpsert
+});
+let QueryKey = /* @__PURE__ */ function(QueryKey) {
+	QueryKey["item"] = "db:recentView:";
+	return QueryKey;
+}({});
+const useUpsert = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const { key: iKey, upsert } = useUpsert$3();
+	const key = [
+		"db",
+		"db:recentView:",
+		...iKey
+	];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ item, trx }) => withTransition(async (trx) => {
+			const itemKey = await upsert({
+				item,
+				trx
+			});
+			await trx.replaceInto("recentView").values({
+				isViewed: false,
+				itemKey,
+				timestamp: Date.now()
+			}).execute();
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		upsert: mutateAsync,
+		key
+	};
+});
+const useRemove = defineMutation(() => {
+	const queryCache = useQueryCache();
+	const key = ["db", "db:recentView:"];
+	const { mutateAsync, ...mutation } = useMutation({
+		mutation: async ({ items, trx }) => withTransition(async (trx) => {
+			await trx.deleteFrom("recentView").where("recentView.timestamp", "is", items).execute();
+		}, trx),
+		onSettled: () => {
+			queryCache.invalidateQueries({ key });
+		},
+		key
+	});
+	return {
+		...mutation,
+		remove: mutateAsync,
+		key
+	};
+});
+const useQuery$1 = (query, otherKeys = [], initialData) => useQuery({
+	query: async () => {
+		const { db } = await import("./index.mjs");
+		return await query(db.selectFrom("recentView"));
+	},
+	key: () => [
+		"db",
+		"db:recentView:",
+		query
+	].concat(otherKeys),
+	staleTime: 15e3,
+	refetchOnMount: "always",
+	initialData,
+	initialDataUpdatedAt: 0
+});
+//#endregion
+//#region lib/config.ts
+var config_exports = /* @__PURE__ */ __exportAll({ useConfig: () => useConfig });
+const configLogger = logger.scoped("db:config");
+const cloneValue = (value) => {
+	if (typeof structuredClone === "function") return structuredClone(value);
+	return JSON.parse(JSON.stringify(value));
+};
+const createDefaultData = (config) => fromPairs(Object.entries(config).map(([name, desc]) => [name, desc.defaultValue]));
+const parseJson = (value, fallback) => {
+	if (!value) return cloneValue(fallback);
+	if (typeof value !== "string") return cloneValue(value);
+	try {
+		return JSON.parse(value);
+	} catch (error) {
+		configLogger.warn("failed to parse config value", error);
+		return cloneValue(fallback);
+	}
+};
+const upsertConfig = async (belongTo, form, data) => {
+	const { db } = await import("./index.mjs");
+	await db.replaceInto("config").values({
+		belongTo,
+		form: JSON.stringify(form),
+		data: JSON.stringify(data)
+	}).execute();
+	configLogger.debug("config persisted", { belongTo });
+};
+const useConfig = (belongTo, form) => {
+	const defaultData = createDefaultData(form);
+	const data = ref(cloneValue(defaultData));
+	let hydrated = false;
+	let saveTimer;
+	const persist = () => {
+		if (saveTimer) clearTimeout(saveTimer);
+		saveTimer = setTimeout(() => {
+			upsertConfig(belongTo, form, data.value).catch((error) => {
+				configLogger.warn("failed to persist config value", { belongTo }, error);
+			});
+		}, 100);
+	};
+	const ready = (async () => {
+		try {
+			const { db } = await import("./index.mjs");
+			const stored = await db.selectFrom("config").select(["form", "data"]).where("belongTo", "=", belongTo).executeTakeFirst();
+			data.value = parseJson(stored?.data, defaultData);
+			configLogger.debug("config hydrated", {
+				belongTo,
+				found: Boolean(stored)
+			});
+			hydrated = true;
+			const storedForm = typeof stored?.form === "string" ? stored.form : JSON.stringify(stored?.form);
+			if (!stored || storedForm !== JSON.stringify(form)) persist();
+		} catch (error) {
+			configLogger.warn("failed to load config value", { belongTo }, error);
+			data.value = cloneValue(defaultData);
+			hydrated = true;
+		}
+	})();
+	watch(data, () => {
+		if (!hydrated) return;
+		persist();
+	}, {
+		deep: true,
+		flush: "sync"
+	});
+	return Object.assign(data, { ready });
+};
+//#endregion
+//#region lib/nativeStore/index.ts
+const nativeStoreLogger = logger.scoped("db:native-store");
+const saveKey = new SourcedValue();
+const cloneDefault = (defaultValue) => {
+	const value = toValue(defaultValue);
+	if (typeof structuredClone === "function") return structuredClone(value);
+	return JSON.parse(JSON.stringify(value));
+};
+const legacyValue = (namespace, key) => {
+	try {
+		return globalThis.localStorage?.getItem(saveKey.toString([namespace, key])) ?? null;
+	} catch {
+		return null;
+	}
+};
+const parseValue = (value, defaultValue) => {
+	if (value === null || value === "") return cloneDefault(defaultValue);
+	if (typeof value !== "string") {
+		if (typeof structuredClone === "function") return structuredClone(value);
+		return JSON.parse(JSON.stringify(value));
+	}
+	try {
+		return JSON.parse(value);
+	} catch (error) {
+		nativeStoreLogger.warn("failed to parse native store value", error);
+		return cloneDefault(defaultValue);
+	}
+};
+const getStoreValue = async (namespace, key) => {
+	const { db } = await import("./index.mjs");
+	return (await db.selectFrom("nativeStore").select("value").where("namespace", "=", namespace).where("key", "=", key).executeTakeFirst())?.value ?? null;
+};
+const setStoreValue = async (namespace, key, value) => {
+	const { db } = await import("./index.mjs");
+	await db.replaceInto("nativeStore").values({
+		namespace,
+		key,
+		value
+	}).execute();
+};
+const useNativeStore = (namespace, key, defaultValue) => {
+	const state = ref(cloneDefault(defaultValue));
+	let version = 0;
+	let hydrated = false;
+	let saveTimer;
+	const persist = (resolvedKey, value) => {
+		if (saveTimer) clearTimeout(saveTimer);
+		const encoded = JSON.stringify(value);
+		saveTimer = setTimeout(() => {
+			setStoreValue(namespace, resolvedKey, encoded).catch((error) => {
+				nativeStoreLogger.warn("failed to persist native store value", {
+					key: resolvedKey,
+					namespace
+				}, error);
+			});
+		}, 100);
+	};
+	const load = async () => {
+		const current = ++version;
+		const resolvedKey = toValue(key);
+		hydrated = false;
+		try {
+			const storeValue = await getStoreValue(namespace, resolvedKey);
+			const storedValue = storeValue ?? legacyValue(namespace, resolvedKey);
+			if (current !== version) return;
+			state.value = parseValue(storedValue, defaultValue);
+			nativeStoreLogger.debug("native store value hydrated", {
+				key: resolvedKey,
+				namespace,
+				source: storeValue === null ? "legacy-or-default" : "database"
+			});
+			hydrated = true;
+			if (storeValue === null) persist(resolvedKey, state.value);
+		} catch (error) {
+			nativeStoreLogger.warn("failed to load native store value", {
+				key: resolvedKey,
+				namespace
+			}, error);
+			if (current !== version) return;
+			state.value = cloneDefault(defaultValue);
+			hydrated = true;
+		}
+	};
+	watch(() => toValue(key), () => void load(), { immediate: true });
+	watch(state, (value) => {
+		if (!hydrated) return;
+		persist(toValue(key), value);
+	}, { deep: true });
+	return state;
+};
+//#endregion
+//#region lib/index.ts
+const databaseLogger = logger.scoped("db:lifecycle");
+databaseLogger.info("database initialization started");
+const isTauriRuntime = isTauri;
+const createDialect = async () => {
+	if (isTauriRuntime()) {
+		const [{ default: Database }, { TauriSqliteDialect }] = await Promise.all([import("@tauri-apps/plugin-sql"), import("kysely-dialect-tauri")]);
+		const database = await Database.load("sqlite:app.db");
+		databaseLogger.info("native sqlite dialect initialized");
+		return new TauriSqliteDialect({ database });
+	}
+	const { createWebDialect } = await import("./web-Bv0LYYK_.mjs");
+	databaseLogger.info("web sqlite dialect initialized");
+	return createWebDialect();
+};
+const db = new Kysely({
+	dialect: await createDialect(),
+	plugins: [new CamelCasePlugin(), new SerializePlugin()]
+});
+//#endregion
+export { config_exports as ConfigDB, utils_exports as DBUtils, favourite_exports as FavouriteDB, history_exports as HistoryDB, itemStore_exports as ItemStoreDB, plugin_exports as PluginArchiveDB, recentView_exports as RecentDB, subscribe_exports as SubscribeDB, db, isTauriRuntime, useConfig, useNativeStore };
+
+//# sourceMappingURL=index.mjs.map