@antelopejs/dms-database 0.0.14 → 0.1.0

package/frontend-vue/tests/queryConsole.test.ts

@@ -0,0 +1,282 @@
+import { describe, expect, it } from 'vitest'
+import type { SchemaSummary } from '../app/build/composables/useDatabaseSchemas'
+import {
+	findSyntaxPlace,
+	prepareQueryPayload,
+	QueryInputError,
+} from '../app/build/composables/useQueryRuntime'
+import {
+	buildCompletionIndex,
+	fieldsAt,
+	QUERY_METHODS,
+} from '../app/build/query/completion'
+import { latestOrderField } from '../app/build/query/examples'
+import {
+	closestName,
+	replaceName,
+	RUN_DOT_CLASSES,
+	unknownName,
+} from '../app/build/query/runs'
+import { filledColumns, numericColumns } from '../app/build/query/tableColumns'
+import {
+	instanceArgument,
+	rowInstance,
+	runTarget,
+	targetFromSource,
+	withInstance,
+} from '../app/build/query/target'
+
+function table(name: string, fields: string[]) {
+	return {
+		name,
+		fields: Object.fromEntries(
+			fields.map((field) => [field, { kind: 'string' }]),
+		),
+		indexes: {},
+		relations: [],
+	} as SchemaSummary['tables'][number]
+}
+
+const shop: SchemaSummary = {
+	id: 'shop',
+	options: {},
+	tables: [
+		table('orders', ['status', 'total']),
+		table('products', ['sku', 'price']),
+	],
+	stats: { tableCount: 2, elementCount: 0, instanceCount: 2 },
+	instances: ['eu', 'us'],
+}
+
+describe('unknown names', () => {
+	it('reads the schema, instance or table an error names', () => {
+		expect(unknownName('Unknown instance "zz" in schema shop')).toEqual({
+			kind: 'instance',
+			name: 'zz',
+		})
+		expect(unknownName('Unknown schema "shoop". Did you mean')).toEqual({
+			kind: 'schema',
+			name: 'shoop',
+		})
+		expect(unknownName('Unknown table "oders" in schema shop')).toEqual({
+			kind: 'table',
+			name: 'oders',
+		})
+		expect(unknownName('Syntax error')).toBeNull()
+	})
+
+	it('suggests the closest instance, as for a table', () => {
+		expect(closestName('zz', ['eu', 'us'])).toBe('eu')
+		expect(closestName('euu', ['eu', 'us'])).toBe('eu')
+		expect(closestName('germany', ['eu', 'us'])).toBeNull()
+		expect(closestName('shoop', ['shop', 'demo'])).toBe('shop')
+	})
+
+	it('replaces the mistyped name where the query names it', () => {
+		const source = 'schemas.shoop.instance("zz").table(\'oders\').count()'
+		expect(replaceName(source, 'schema', 'shoop', 'shop')).toBe(
+			'schemas.shop.instance("zz").table(\'oders\').count()',
+		)
+		expect(replaceName(source, 'instance', 'zz', 'eu')).toBe(
+			'schemas.shoop.instance("eu").table(\'oders\').count()',
+		)
+		expect(replaceName(source, 'table', 'oders', 'orders')).toBe(
+			'schemas.shoop.instance("zz").table(\'orders\').count()',
+		)
+		expect(
+			replaceName('schemas["shoop"].instance()', 'schema', 'shoop', 'dms-core'),
+		).toBe('schemas["dms-core"].instance()')
+		// A longer schema id sharing the prefix is left alone.
+		expect(replaceName('schemas.shoppers', 'schema', 'shop', 'x')).toBe(
+			'schemas.shoppers',
+		)
+	})
+})
+
+describe('query runtime errors', () => {
+	it('names an unknown schema', () => {
+		let error: unknown
+		try {
+			prepareQueryPayload('schemas.shoop.instance().table("orders")', [shop])
+		} catch (caught) {
+			error = caught
+		}
+		expect(error).toBeInstanceOf(QueryInputError)
+		expect((error as QueryInputError).problem).toEqual({
+			kind: 'unknown_schema',
+			schema: 'shoop',
+		})
+		expect((error as Error).message).toBe('Unknown schema "shoop"')
+	})
+
+	it('points a syntax error where the text breaks', () => {
+		let error: unknown
+		try {
+			prepareQueryPayload('schemas.shop.instance("eu").table("orders"', [shop])
+		} catch (caught) {
+			error = caught
+		}
+		expect(error).toBeInstanceOf(QueryInputError)
+		expect((error as QueryInputError).problem).toMatchObject({
+			kind: 'syntax',
+			place: { line: 1, column: 43 },
+		})
+		expect((error as Error).message).toMatch(/^Syntax error at line 1/)
+	})
+
+	it('accepts a closing semicolon', () => {
+		const prepared = prepareQueryPayload(
+			'schemas.shop.instance().table("orders").count();\n',
+			[shop],
+		)
+		expect(prepared.source).toBe(
+			'schemas.shop.instance().table("orders").count();',
+		)
+	})
+})
+
+describe('syntax places', () => {
+	it('finds where the parser stops, with its line and column', () => {
+		expect(findSyntaxPlace('a.b("x").c(1)')).toBeNull()
+		expect(findSyntaxPlace('a.b("x"\n  .c(1))')).toBeNull()
+		expect(findSyntaxPlace('a.b(1))')).toEqual({ line: 1, column: 7 })
+		// An unterminated string breaks where the text ends.
+		expect(findSyntaxPlace('a.b(\n  "open)')).toEqual({ line: 2, column: 9 })
+		// Brackets in strings and comments do not count.
+		expect(findSyntaxPlace('a.b(")") // (\n')).toBeNull()
+	})
+})
+
+describe('query targets', () => {
+	it('reads the chain a query text names', () => {
+		expect(
+			targetFromSource('schemas.shop.instance("eu").table("orders").count()'),
+		).toEqual({ schema: 'shop', instance: 'eu', table: 'orders' })
+		expect(
+			targetFromSource(
+				'schemas["dms-core"].instance(CROSS_INSTANCE).table(\'users\')',
+			),
+		).toEqual({ schema: 'dms-core', instance: '*', table: 'users' })
+		expect(targetFromSource('schemas.demo.instance().table("tags')).toEqual({
+			schema: 'demo',
+			instance: '',
+			table: undefined,
+		})
+		expect(targetFromSource('1 + 1')).toEqual({})
+	})
+
+	it('names where a past run pointed, failed ones included', () => {
+		expect(
+			runTarget({
+				query: {
+					stages: [
+						{ stage: 'schema', options: { id: 'shop' } },
+						{ stage: 'instance', options: { id: 'eu' } },
+						{ stage: 'table', options: { id: 'orders' } },
+					],
+				},
+				source: 'whatever',
+			}),
+		).toEqual({ schema: 'shop', instance: 'eu', table: 'orders' })
+		expect(
+			runTarget({ query: {}, source: 'schemas.demo.instance().table("tags"' }),
+		).toEqual({ schema: 'demo', instance: '', table: undefined })
+	})
+
+	it('opens a row of a cross-instance read in its own instance', () => {
+		const all = { schema: 'shop', table: 'orders', instance: '*' }
+		expect(rowInstance(all, { _id: 'o1', _instance: 'eu' })).toBe('eu')
+		expect(rowInstance(all, { _id: 'o1', _instance: null })).toBe('')
+		expect(rowInstance(all, { _id: 'o1' })).toBeNull()
+		expect(rowInstance({ ...all, instance: 'us' }, { _instance: 'eu' })).toBe(
+			'us',
+		)
+		expect(rowInstance({ ...all, instance: '' }, {})).toBe('')
+	})
+
+	it('reads the instance a link into the console names', () => {
+		expect(instanceArgument(undefined)).toBe('')
+		expect(instanceArgument('eu')).toBe('"eu"')
+		expect(instanceArgument('all')).toBe('CROSS_INSTANCE')
+		// No alias: any other value is a named instance.
+		expect(instanceArgument('__CROSS_INSTANCE__')).toBe('"__CROSS_INSTANCE__"')
+	})
+
+	it('reads an empty default-instance read in a named instance', () => {
+		expect(
+			withInstance(
+				'schemas.shop.instance().table("orders").filter((r) => r.key("x"))',
+				'shop',
+				'eu',
+			),
+		).toBe(
+			'schemas.shop.instance("eu").table("orders").filter((r) => r.key("x"))',
+		)
+		expect(
+			withInstance(
+				'schemas["dms-core"] . instance( ).table("users")',
+				'dms-core',
+				'us',
+			),
+		).toBe('schemas["dms-core"] . instance("us").table("users")')
+		// Another schema, or one sharing the prefix, is left alone.
+		expect(
+			withInstance('schemas.shopper.instance().table("x")', 'shop', 'eu'),
+		).toBe('schemas.shopper.instance().table("x")')
+	})
+})
+
+describe('completions', () => {
+	const index = buildCompletionIndex([shop])
+
+	it('offers only methods the query language has', () => {
+		expect(QUERY_METHODS).not.toContain('limit')
+		expect(QUERY_METHODS).toContain('slice')
+	})
+
+	it('offers the fields of the chain table only', () => {
+		expect(fieldsAt(index, { schema: 'shop', table: 'orders' })).toEqual([
+			'status',
+			'total',
+		])
+		expect(fieldsAt(index, { schema: 'shop' })).toEqual([
+			'status',
+			'total',
+			'sku',
+			'price',
+		])
+		expect(fieldsAt(index, { schema: 'shop', table: 'nope' })).toHaveLength(4)
+	})
+})
+
+describe('result rendering', () => {
+	it('leaves out columns null in every row and right-aligns numbers', () => {
+		const rows = [
+			{ _id: 'a', total: 3, _instance: null, note: null },
+			{ _id: 'b', total: null, _instance: null, note: 'x' },
+		]
+		const columns = ['_id', 'total', '_instance', 'note']
+		expect(filledColumns(rows, columns)).toEqual(['_id', 'total', 'note'])
+		expect(filledColumns([{ a: null }], ['a'])).toEqual(['a'])
+		expect(numericColumns(rows, columns)).toEqual(['total'])
+	})
+
+	it('orders "latest rows" by a date only when the table has one', () => {
+		expect(
+			latestOrderField({
+				name: 'orders',
+				fields: { status: { kind: 'string' }, created_at: { kind: 'date' } },
+			}),
+		).toBe('created_at')
+		expect(
+			latestOrderField({ name: 'logs', fields: { at: { kind: 'date' } } }),
+		).toBe('at')
+		expect(
+			latestOrderField({ name: 'tags', fields: { label: { kind: 'string' } } }),
+		).toBeNull()
+	})
+
+	it('tells a run that changed data from a fast one', () => {
+		expect(RUN_DOT_CLASSES.changed).not.toBe(RUN_DOT_CLASSES.fast)
+	})
+})

package/frontend-vue/tests/queryRuntime.test.ts

@@ -1,6 +1,6 @@
 import { expect, it } from 'vitest'
-import type { SchemaSummary } from '../app/composables/useDatabaseSchemas'
-import { prepareQueryPayload } from '../app/composables/useQueryRuntime'
+import type { SchemaSummary } from '../app/build/composables/useDatabaseSchemas'
+import { prepareQueryPayload } from '../app/build/composables/useQueryRuntime'
 
 const schema: SchemaSummary = {
 	id: 'parity',

package/frontend-vue/tests/registration.test.ts

@@ -2,26 +2,23 @@ import { expect, it, vi } from 'vitest'
 import { readFileSync } from 'node:fs'
 import frontendModule from '../dms.frontend'
 
-const schemasPage = readFileSync(
-	new URL('../app/custom-pages/database/schemas.vue', import.meta.url),
-	'utf8',
-)
-const relationEdge = readFileSync(
-	new URL('../app/components/DiagramRelationEdge.vue', import.meta.url),
-	'utf8',
-)
+function source(path: string): string {
+	return readFileSync(new URL(path, import.meta.url), 'utf8')
+}
 
 it('uses the DMS client-only wrapper for the Vue Flow schema diagram', () => {
-	expect(schemasPage).toContain('<DmsClientOnly>')
-	expect(schemasPage).not.toContain('<ClientOnly>')
+	const diagram = source('../app/components/SchemaDiagram.vue')
+	expect(diagram).toContain('<DmsClientOnly')
+	expect(diagram).not.toContain('<ClientOnly>')
 })
 
 it('does not route relation labels through Vue Flow EdgeText measurement', () => {
-	expect(relationEdge).toContain(':label="undefined"')
-	expect(relationEdge).toContain('<text')
+	const edge = source('../app/components/DiagramRelationEdge.vue')
+	expect(edge).toContain(':label="undefined"')
+	expect(edge).toContain('<text')
 })
 
-it('preserves all database page keys, component aliases and preloaders', async () => {
+it('registers every component under the module prefix the backend names', async () => {
 	const registerComponent = vi.fn()
 	const registerPage = vi.fn()
 	await frontendModule.setup({
@@ -36,18 +33,32 @@ it('preserves all database page keys, component aliases and preloaders', async (
 		provide: vi.fn(),
 		use: vi.fn(),
 	})
-	expect(registerPage.mock.calls.map(([name]) => name)).toEqual([
-		'database/data',
-		'database/overview',
-		'database/query',
-		'database/schemas',
-	])
-	for (const [name, component, preload] of registerPage.mock.calls) {
-		const alias = `DmsDatabase${name.split('/')[1].replace(/^./, (character: string) => character.toUpperCase())}`
-		expect(registerComponent).toHaveBeenCalledWith(alias, component)
-		expect(preload).toBeTypeOf('function')
-	}
+	expect(frontendModule.componentPrefix).toBe('DmsDatabase')
+	expect(registerPage).not.toHaveBeenCalled()
 	const names = registerComponent.mock.calls.map(([name]) => name)
-	expect(names).toContain('DmsDatabaseDataGrid')
+	// The names the backend pages send, without the prefix the SDK adds.
+	for (const name of [
+		'ConnectionStatus',
+		'TableInspector',
+		'SchemaDiagram',
+		'DataBrowser',
+		'QueryConsole',
+	]) {
+		expect(names).toContain(name)
+	}
+	expect(names.every((name) => !name.startsWith('Dms'))).toBe(true)
 	expect(new Set(names).size).toBe(names.length)
 })
+
+it('names every custom component the backend pages render', () => {
+	const backend = ['overview', 'schemas', 'diagram', 'data', 'query']
+		.map((page) => source(`../../src/pages/${page}.ts`))
+		.join('\n')
+	const named = [
+		...backend.matchAll(/CustomComponent\("DmsDatabase(\w+)"\)/g),
+	].map(([, name]) => name)
+	expect(named.length).toBeGreaterThan(0)
+	for (const name of named) {
+		expect(() => source(`../app/components/${name}.vue`)).not.toThrow()
+	}
+})

package/frontend-vue/tests/schemasFilters.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from 'vitest'
+import {
+	EMPTY_FILTER_STATE,
+	filterParams,
+	isFiltered,
+	parseHas,
+	readFilterState,
+	sourceQuery,
+	toggleHas,
+	withFilterState,
+	withScope,
+} from '../app/build/schemas/filterState'
+
+describe('Schemas filter bar state', () => {
+	it('reads nothing as no filter, empty values included', () => {
+		expect(readFilterState({})).toEqual(EMPTY_FILTER_STATE)
+		const empty = { scope: '', instance: '', q: '', has: '' }
+		expect(readFilterState(empty)).toEqual(EMPTY_FILTER_STATE)
+		expect(isFiltered(readFilterState(empty))).toBe(false)
+	})
+
+	it('reads and writes back every key', () => {
+		const query = {
+			scope: 'shop',
+			instance: 'eu',
+			q: ' invoice ',
+			has: 'empty,relations',
+		}
+		const state = readFilterState(query)
+		expect(state).toEqual({
+			scope: 'shop',
+			instance: { kind: 'named', id: 'eu' },
+			q: 'invoice',
+			has: ['relations', 'empty'],
+		})
+		expect(filterParams(state)).toEqual({
+			scope: 'shop',
+			instance: 'eu',
+			q: 'invoice',
+			has: 'relations,empty',
+		})
+		expect(isFiltered(state)).toBe(true)
+	})
+
+	it('keeps the other keys and drops unset and empty bar keys', () => {
+		const query = {
+			record: 'shop::orders',
+			scope: 'shop',
+			instance: '',
+			q: '',
+			has: '',
+		}
+		expect(withFilterState(query, readFilterState(query))).toEqual({
+			record: 'shop::orders',
+			scope: 'shop',
+		})
+		expect(
+			withFilterState(query, { ...EMPTY_FILTER_STATE, q: 'line' }),
+		).toEqual({ record: 'shop::orders', q: 'line' })
+	})
+
+	it('reads no instance as the default one, and all as every instance', () => {
+		expect(readFilterState({}).instance).toEqual({ kind: 'default' })
+		expect(readFilterState({ instance: 'all' }).instance).toEqual({
+			kind: 'all',
+		})
+		const named = readFilterState({ instance: 'eu' })
+		expect(named.instance).toEqual({ kind: 'named', id: 'eu' })
+		expect(filterParams(EMPTY_FILTER_STATE).instance).toBeUndefined()
+		expect(
+			filterParams({ ...EMPTY_FILTER_STATE, instance: { kind: 'all' } })
+				.instance,
+		).toBe('all')
+		expect(
+			isFiltered({ ...EMPTY_FILTER_STATE, instance: { kind: 'all' } }),
+		).toBe(true)
+	})
+
+	it('keeps known structure flags once, in a fixed order', () => {
+		expect(parseHas('empty, bogus,relations,empty')).toEqual([
+			'relations',
+			'empty',
+		])
+		let state = toggleHas(EMPTY_FILTER_STATE, 'empty')
+		state = toggleHas(state, 'relations')
+		expect(state.has).toEqual(['relations', 'empty'])
+		expect(toggleHas(state, 'empty').has).toEqual(['relations'])
+	})
+
+	it('drops a named instance with the schema it belongs to', () => {
+		const state = {
+			...EMPTY_FILTER_STATE,
+			scope: 'shop',
+			instance: { kind: 'named' as const, id: 'eu' },
+		}
+		expect(withScope(state, 'shop').instance).toEqual(state.instance)
+		expect(withScope(state, 'blog').instance).toEqual({ kind: 'default' })
+		expect(withScope(state, null).instance).toEqual({ kind: 'default' })
+		const every = { ...state, instance: { kind: 'all' as const } }
+		expect(withScope(every, 'blog').instance).toEqual({ kind: 'all' })
+	})
+
+	it('queries the source as the table view does', () => {
+		expect(sourceQuery(EMPTY_FILTER_STATE)).toEqual({})
+		expect(
+			sourceQuery(
+				readFilterState({ scope: 'shop', instance: 'all', has: 'empty' }),
+			),
+		).toEqual({
+			filter_scope: 'is:shop',
+			filter_instance: 'is:all',
+			filter_has: 'is:empty',
+		})
+	})
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms-database",
-  "version": "0.0.14",
+  "version": "0.1.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -44,17 +44,17 @@
     "test:frontend": "ajs dms verify-source --layer node_modules/@antelopejs/dms/frontend-vue --module frontend-vue"
   },
   "dependencies": {
-    "@antelopejs/interface-api": ">=0.0.13 <1.0.0",
+    "@antelopejs/interface-api": ">=0.0.14 <1.0.0",
     "@antelopejs/interface-api-util": ">=0.1.2 <1.0.0",
     "@antelopejs/interface-core": ">=0.1.1 <1.0.0",
     "@antelopejs/interface-database": ">=0.1.8 <1.0.0",
     "@antelopejs/interface-database-decorators": ">=0.1.7 <1.0.0",
-    "@antelopejs/interface-dms": ">=0.2.8 <1.0.0"
+    "@antelopejs/interface-dms": ">=0.5.1 <1.0.0"
   },
   "devDependencies": {
-    "@antelopejs/core": ">=1.10.1 <2",
-    "@antelopejs/dms": ">=0.5.0 <1.0.0",
-    "@antelopejs/dms-frontend": ">=0.3.6 <0.4.0",
+    "@antelopejs/core": ">=1.13.5 <2",
+    "@antelopejs/dms": ">=0.7.4 <0.8.0",
+    "@antelopejs/dms-frontend": ">=0.5.2 <0.6.0",
     "@antelopejs/tooling-configs": ">=0.0.7 <1.0.0",
     "@types/chai": "^5.2.3",
     "@types/mocha": "^10.0.10",
@@ -73,7 +73,7 @@
     "typescript": "^6.0.3"
   },
   "optionalDependencies": {
-    "@antelopejs/interface-dms-automation": ">=0.1.0 <1.0.0"
+    "@antelopejs/interface-dms-automation": ">=0.1.1 <1.0.0"
   },
   "packageManager": "pnpm@10.2.0",
   "antelopeJs": {

package/frontend-vue/app/components/QueryFavoritesPanel.vue

@@ -1,127 +0,0 @@
-<script setup lang="ts">
-import type { DropdownMenuItem } from "@nuxt/ui";
-import type { QueryScope, SavedQuery } from "../composables/useQueryStore";
-import { formatDatabaseRelativeTime } from "../utils/relativeTime";
-
-interface Props {
-	items: SavedQuery[];
-	scope: QueryScope;
-}
-
-const props = defineProps<Props>();
-
-const emit = defineEmits<{
-	"update:scope": [value: QueryScope];
-	load: [query: SavedQuery];
-	edit: [query: SavedQuery];
-	delete: [id: string];
-}>();
-
-const { t } = useI18n();
-const { user } = useUserSession();
-
-const internalScope = computed<QueryScope>({
-	get: () => props.scope,
-	set: (value) => emit("update:scope", value),
-});
-
-const scopeItems = computed(() => [
-	{ label: t("dms_database.query.scopeMe"), value: "me" as const },
-	{ label: t("dms_database.query.scopeShared"), value: "shared" as const },
-]);
-
-function menuItems(item: SavedQuery): DropdownMenuItem[][] {
-	const load: DropdownMenuItem = {
-		label: t("dms_database.query.itemMenu.load"),
-		icon: "i-ph-arrow-square-out",
-		onSelect: () => emit("load", item),
-	};
-	// The Team tab also lists other users' queries; only the owner may edit
-	// or delete them (the API enforces the same rule).
-	if (item.userId !== user.value?._id) return [[load]];
-	return [
-		[
-			load,
-			{
-				label: t("dms_database.query.itemMenu.edit"),
-				icon: "i-ph-pencil-simple",
-				onSelect: () => emit("edit", item),
-			},
-		],
-		[
-			{
-				label: t("dms_database.query.itemMenu.delete"),
-				icon: "i-ph-trash",
-				color: "error",
-				onSelect: () => emit("delete", item.id),
-			},
-		],
-	];
-}
-</script>
-
-<template>
-	<DmsCard :padded="false" class="flex flex-col">
-		<header class="flex items-center gap-2.5 px-4 pt-4 pb-2.5">
-			<UIcon name="i-ph-star" class="text-primary shrink-0" />
-			<h3 class="text-highlighted text-sm font-semibold">
-				{{ $t("dms_database.query.favorites") }}
-			</h3>
-			<DmsSegmented
-				v-model="internalScope"
-				:items="scopeItems"
-				:aria-label="$t('dms_database.query.scopeMe')"
-				class="ml-auto"
-			/>
-		</header>
-
-		<ul
-			v-if="items.length > 0"
-			class="flex-1 overflow-y-auto px-1.5 pb-2 space-y-0.5"
-		>
-			<li
-				v-for="item in items"
-				:key="item.id"
-				class="group flex items-center gap-2.5 rounded-md px-2.5 py-2.5 cursor-pointer hover:bg-elevated transition-colors"
-				@click="emit('load', item)"
-				@keydown.enter.prevent="emit('load', item)"
-			>
-				<UIcon name="i-ph-star-fill" class="text-primary shrink-0 size-3.5" />
-				<div class="min-w-0 flex-1">
-					<div
-						class="text-toned text-[12.5px] font-semibold truncate flex items-center gap-1.5"
-					>
-						<span class="truncate">{{ item.name }}</span>
-						<UIcon
-							v-if="item.shared"
-							name="i-ph-users"
-							class="text-info shrink-0 size-3.5"
-							:aria-label="$t('dms_database.query.sharedBadge')"
-						/>
-					</div>
-				</div>
-				<span class="text-dimmed font-mono text-[10.5px] shrink-0">
-					{{ formatDatabaseRelativeTime(item.createdAt) }}
-				</span>
-				<UDropdownMenu :items="menuItems(item)" :content="{ align: 'end' }">
-					<UButton
-						icon="i-ph-dots-three-vertical"
-						variant="ghost"
-						color="neutral"
-						size="xs"
-						class="opacity-0 group-hover:opacity-100 transition-opacity shrink-0"
-						:aria-label="item.name"
-						@click.stop
-					/>
-				</UDropdownMenu>
-			</li>
-		</ul>
-
-		<div
-			v-else
-			class="flex-1 flex items-center justify-center px-4 py-6 text-xs text-dimmed text-center"
-		>
-			{{ $t("dms_database.query.emptyFavorites") }}
-		</div>
-	</DmsCard>
-</template>