reimplemented most db command functions with ORM (migrate from tauri command invoke

Author: HuakunShen

apps/desktop/package.json

@@ -39,7 +39,7 @@
 		"lz-string": "^1.5.0",
 		"pretty-bytes": "^6.1.1",
 		"semver": "^7.7.1",
-		"svelte-inspect-value": "^0.3.0",
+		"svelte-inspect-value": "^0.5.0",
 		"svelte-sonner": "^0.3.28",
 		"sveltekit-superforms": "^2.23.1",
 		"tauri-plugin-clipboard-api": "^2.1.11",

apps/desktop/src/lib/cmds/builtin.ts

@@ -242,6 +242,23 @@ export const rawBuiltinCmds: BuiltinCmd[] = [
 		},
 		keywords: ["extension", "troubleshooter"]
 	},
+	{
+		name: "ORM Troubleshooter",
+		icon: {
+			type: IconEnum.Iconify,
+			value: "material-symbols:database"
+		},
+		description: "",
+		flags: {
+			developer: true,
+			dev: true
+		},
+		function: async () => {
+			appState.clearSearchTerm()
+			goto(i18n.resolveRoute("/app/troubleshooters/orm"))
+		},
+		keywords: ["extension", "troubleshooter", "database", "orm"]
+	},
 	{
 		name: "Create Quicklink",
 		icon: {

apps/desktop/src/lib/orm/cmds.ts

@@ -0,0 +1,343 @@
+import * as relations from "@kksh/drizzle/relations"
+import * as schema from "@kksh/drizzle/schema"
+import { CmdType, Ext, ExtCmd, ExtData, SearchMode, SearchModeEnum, SQLSortOrder, SQLSortOrderEnum } from "@kunkunapi/src/models"
+import * as orm from "drizzle-orm"
+import type { SelectedFields } from "drizzle-orm/sqlite-core"
+import * as v from "valibot"
+import { db } from "./database"
+
+/* -------------------------------------------------------------------------- */
+/*                             Built-in Extensions                            */
+/* -------------------------------------------------------------------------- */
+
+/* -------------------------------------------------------------------------- */
+/*                               Extension CRUD                               */
+/* -------------------------------------------------------------------------- */
+export async function getUniqueExtensionByIdentifier(identifier: string): Promise<Ext | undefined> {
+	const ext = await db
+		.select()
+		.from(schema.extensions)
+		.where(orm.eq(schema.extensions.identifier, identifier))
+		.get()
+	return v.parse(v.optional(Ext), ext)
+}
+
+/**
+ * Use this function when you expect the extension to exist. Such as builtin extensions.
+ * @param identifier
+ * @returns
+ */
+export function getExtensionByIdentifierExpectExists(identifier: string): Promise<Ext> {
+	return getUniqueExtensionByIdentifier(identifier).then((ext) => {
+		if (!ext) {
+			throw new Error(`Unexpexted Error: Extension ${identifier} not found`)
+		}
+		return ext
+	})
+}
+
+export async function getAllExtensions(): Promise<Ext[]> {
+	const exts = await db.select().from(schema.extensions).all()
+	return v.parse(v.array(Ext), exts)
+}
+
+/**
+ * There can be duplicate extensions with the same identifier. Store and Dev extensions can have the same identifier.
+ * But install path must be unique.
+ * @param path
+ */
+export async function getUniqueExtensionByPath(path: string) {
+	const ext = await db
+		.select()
+		.from(schema.extensions)
+		.where(orm.eq(schema.extensions.path, path))
+		.get()
+	return v.parse(Ext, ext)
+}
+
+export function getAllExtensionsByIdentifier(identifier: string): Promise<Ext[]> {
+	return db
+		.select()
+		.from(schema.extensions)
+		.where(orm.eq(schema.extensions.identifier, identifier))
+		.all()
+		.then((exts) => v.parse(v.array(Ext), exts))
+}
+
+export function deleteExtensionByPath(path: string): Promise<void> {
+	return db
+		.delete(schema.extensions)
+		.where(orm.eq(schema.extensions.path, path))
+		.run()
+		.then(() => undefined)
+}
+
+export function deleteExtensionByExtId(extId: number): Promise<void> {
+	return db
+		.delete(schema.extensions)
+		.where(orm.eq(schema.extensions.extId, extId))
+		.run()
+		.then(() => undefined)
+}
+
+/* -------------------------------------------------------------------------- */
+/*                           Extension Command CRUD                           */
+/* -------------------------------------------------------------------------- */
+
+// export async function getExtensionWithCmdsByIdentifier(identifier: string): Promise<ExtWithCmds> {
+// 	const ext = await db
+// 		.select({
+// 			...schema.extensions,
+// 			commands: relations.commandsRelations
+// 		})
+// 		.from(schema.extensions)
+// 		.leftJoin(schema.commands, orm.eq(schema.extensions.extId, schema.commands.extId))
+// 		.where(orm.eq(schema.extensions.identifier, identifier))
+// 		.get()
+
+// 	// return v.parse(v.nullable(ExtWithCmds), ext);
+// }
+
+export async function getCmdById(cmdId: number): Promise<ExtCmd> {
+	const cmd = await db
+		.select()
+		.from(schema.commands)
+		.where(orm.eq(schema.commands.cmdId, cmdId))
+		.get()
+	return v.parse(ExtCmd, cmd)
+}
+
+export async function getAllCmds(): Promise<ExtCmd[]> {
+	const cmds = await db.select().from(schema.commands).all()
+	return v.parse(v.array(ExtCmd), cmds)
+}
+
+export function getCommandsByExtId(extId: number) {
+	return db
+		.select()
+		.from(schema.commands)
+		.where(orm.eq(schema.commands.extId, extId))
+		.all()
+		.then((cmds) => v.parse(v.array(ExtCmd), cmds))
+}
+
+export function deleteCmdById(cmdId: number) {
+	return db
+		.delete(schema.commands)
+		.where(orm.eq(schema.commands.cmdId, cmdId))
+		.run()
+		.then(() => undefined)
+}
+
+export function updateCmdByID(data: {
+	cmdId: number
+	name: string
+	cmdType: CmdType
+	data: string
+	alias?: string
+	hotkey?: string
+	enabled: boolean
+}) {
+	return db
+		.update(schema.commands)
+		.set({
+			name: data.name,
+			type: data.cmdType,
+			data: data.data,
+			alias: data.alias, // optional
+			hotkey: data.hotkey, // optional
+			enabled: data.enabled
+			// in drizzle schema, use integer({ mode: 'boolean' }) for boolean sqlite
+			// enabled: data.enabled ? String(data.enabled) : undefined
+		})
+		.where(orm.eq(schema.commands.cmdId, data.cmdId))
+		.run()
+		.then(() => undefined)
+}
+
+/* -------------------------------------------------------------------------- */
+/*                             Extension Data CRUD                            */
+/* -------------------------------------------------------------------------- */
+export const ExtDataField = v.union([v.literal("data"), v.literal("search_text")])
+export type ExtDataField = v.InferOutput<typeof ExtDataField>
+
+function convertRawExtDataToExtData(rawData?: {
+	createdAt: string
+	updatedAt: string
+	data: null | string
+	searchText?: null | string
+	dataId: number
+	extId: number
+	dataType: string
+}): ExtData | undefined {
+	if (!rawData) {
+		return rawData
+	}
+	const parsedRes = v.safeParse(ExtData, {
+		...rawData,
+		createdAt: new Date(rawData.createdAt),
+		updatedAt: new Date(rawData.updatedAt),
+		data: rawData.data ?? undefined,
+		searchText: rawData.searchText ?? undefined
+	})
+	if (parsedRes.success) {
+		return parsedRes.output
+	} else {
+		console.error("Extension Data Parse Failure", parsedRes.issues)
+		throw new Error("Fail to parse extension data")
+	}
+}
+
+export function createExtensionData(data: {
+	extId: number
+	dataType: string
+	data: string
+	searchText?: string
+}) {
+	return db.insert(schema.extensionData).values(data).run()
+}
+
+export function getExtensionDataById(dataId: number, fields?: ExtDataField[]) {
+	const _fields = fields ?? []
+	const selectQuery: SelectedFields = {
+		dataId: schema.extensionData.dataId,
+		extId: schema.extensionData.extId,
+		dataType: schema.extensionData.dataType,
+		metadata: schema.extensionData.metadata,
+		createdAt: schema.extensionData.createdAt,
+		updatedAt: schema.extensionData.updatedAt
+		// data: schema.extensionData.data,
+		// searchText: schema.extensionData.searchText
+	}
+	if (_fields.includes("data")) {
+		selectQuery["data"] = schema.extensionData.data
+	}
+	if (_fields.includes("search_text")) {
+		selectQuery["searchText"] = schema.extensionData.searchText
+	}
+	return db
+		.select(selectQuery)
+		.from(schema.extensionData)
+		.where(orm.eq(schema.extensionData.dataId, dataId))
+		.get()
+		.then((rawData) => {
+			console.log("Raw Data", rawData)
+			// @ts-expect-error - rawData is unknown, but will be safe parsed with valibot
+			return convertRawExtDataToExtData(rawData)
+		})
+}
+
+export async function searchExtensionData(searchParams: {
+	extId: number
+	searchMode: SearchMode
+	dataId?: number
+	dataType?: string
+	searchText?: string
+	afterCreatedAt?: string
+	beforeCreatedAt?: string
+	limit?: number
+	offset?: number
+	orderByCreatedAt?: SQLSortOrder
+	orderByUpdatedAt?: SQLSortOrder
+	fields?: ExtDataField[]
+}): Promise<ExtData[]> {
+	const fields = v.parse(v.optional(v.array(ExtDataField), []), searchParams.fields)
+	const _fields = fields ?? []
+	
+	// Build the select query based on fields
+	const selectQuery: SelectedFields = {
+		dataId: schema.extensionData.dataId,
+		extId: schema.extensionData.extId,
+		dataType: schema.extensionData.dataType,
+		createdAt: schema.extensionData.createdAt,
+		updatedAt: schema.extensionData.updatedAt
+	}
+
+	if (_fields.includes("data")) {
+		selectQuery["data"] = schema.extensionData.data
+	}
+	if (_fields.includes("search_text")) {
+		selectQuery["searchText"] = schema.extensionData.searchText
+	}
+
+	// Build the query
+	const query = db.select(selectQuery).from(schema.extensionData)
+
+	// Add conditions
+	const conditions = [orm.eq(schema.extensionData.extId, searchParams.extId)]
+
+	if (searchParams.dataId) {
+		conditions.push(orm.eq(schema.extensionData.dataId, searchParams.dataId))
+	}
+
+	if (searchParams.dataType) {
+		conditions.push(orm.eq(schema.extensionData.dataType, searchParams.dataType))
+	}
+
+	if (searchParams.searchText) {
+		switch (searchParams.searchMode) {
+			case SearchModeEnum.ExactMatch:
+				conditions.push(orm.eq(schema.extensionData.searchText, searchParams.searchText))
+				break
+			case SearchModeEnum.Like:
+				conditions.push(orm.like(schema.extensionData.searchText, `%${searchParams.searchText}%`))
+				break
+			case SearchModeEnum.FTS:
+				// For FTS, we need to use a raw SQL query since Drizzle doesn't support MATCH directly
+				conditions.push(orm.sql`${schema.extensionDataFts.searchText} MATCH ${searchParams.searchText}`)
+				break
+		}
+	}
+
+	if (searchParams.afterCreatedAt) {
+		conditions.push(orm.gt(schema.extensionData.createdAt, searchParams.afterCreatedAt))
+	}
+
+	if (searchParams.beforeCreatedAt) {
+		conditions.push(orm.lt(schema.extensionData.createdAt, searchParams.beforeCreatedAt))
+	}
+
+	// Add ordering
+	if (searchParams.orderByCreatedAt) {
+		query.orderBy(
+			searchParams.orderByCreatedAt === SQLSortOrderEnum.Asc
+				? orm.asc(schema.extensionData.createdAt)
+				: orm.desc(schema.extensionData.createdAt)
+		)
+	}
+
+	if (searchParams.orderByUpdatedAt) {
+		query.orderBy(
+			searchParams.orderByUpdatedAt === SQLSortOrderEnum.Asc
+				? orm.asc(schema.extensionData.updatedAt)
+				: orm.desc(schema.extensionData.updatedAt)
+		)
+	}
+
+	// Add limit and offset
+	if (searchParams.limit) {
+		query.limit(searchParams.limit)
+	}
+
+	if (searchParams.offset) {
+		query.offset(searchParams.offset)
+	}
+
+	// Execute query and convert results
+	const results = await query.where(orm.and(...conditions)).all()
+	return results.map((rawData) => {
+		// @ts-expect-error - rawData is unknown, but will be safe parsed with valibot
+		return convertRawExtDataToExtData(rawData)
+	}).filter((item): item is ExtData => item !== undefined)
+}
+
+// export async function getNCommands(n: number):
+// export function createExtension(ext: {
+// 	identifier: string
+// 	version: string
+// 	enabled?: boolean
+// 	path?: string
+// 	data?: any
+// }) {
+// 	return invoke<void>(generateJarvisPluginCommand("create_extension"), ext)
+// }