@antelopejs/dms-database 0.0.13 → 0.1.0

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

@@ -0,0 +1,205 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { ref } from 'vue'
+import { parseDraft } from '../app/build/data/cellValues'
+import { undoBodies, useStagedEdits } from '../app/build/data/stagedEdits'
+import { DiagramHistory } from '../app/build/diagram/history'
+import { toCsv } from '../app/build/query/csv'
+import { groupByDay, runKind } from '../app/build/query/runs'
+import { readQueryTarget } from '../app/build/query/target'
+import {
+	decodeMatch,
+	tableAccess,
+	tableLink,
+} from '../app/build/utils/databaseLinks'
+import type { HistoryEntry } from '../app/build/composables/useQueryStore'
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe('cell drafts', () => {
+	it('keeps the stored type of a cell', () => {
+		expect(parseDraft('42.5', 1, 'number')).toEqual({
+			ok: true,
+			value: 42.5,
+			unchanged: false,
+		})
+		expect(parseDraft('nope', 1, 'number')).toEqual({
+			ok: false,
+			reason: 'number',
+		})
+		expect(parseDraft('TRUE', false, 'boolean')).toMatchObject({
+			ok: true,
+			value: true,
+		})
+	})
+
+	it('types an empty cell from its column and leaves it empty when nothing is typed', () => {
+		expect(parseDraft('7', null, 'number')).toMatchObject({
+			ok: true,
+			value: 7,
+		})
+		expect(parseDraft('', null, 'string')).toMatchObject({
+			ok: true,
+			unchanged: true,
+		})
+	})
+
+	it('reports an echo of the stored value as unchanged', () => {
+		expect(parseDraft('42', 42, 'number')).toMatchObject({ unchanged: true })
+	})
+})
+
+describe('staged edits', () => {
+	function staged() {
+		vi.stubGlobal('useDmsState', (_key: string, init: () => unknown) =>
+			ref(init()),
+		)
+		return useStagedEdits()
+	}
+
+	it('keeps the first stored value and drops a cell set back to it', () => {
+		const edits = staged()
+		edits.stage('tab', {
+			rowId: 'r1',
+			field: 'status',
+			before: 'pending',
+			after: 'paid',
+		})
+		edits.stage('tab', {
+			rowId: 'r1',
+			field: 'status',
+			before: 'paid',
+			after: 'refunded',
+		})
+		expect(edits.get('tab', 'r1', 'status')).toEqual({
+			before: 'pending',
+			after: 'refunded',
+		})
+		edits.stage('tab', {
+			rowId: 'r1',
+			field: 'status',
+			before: 'refunded',
+			after: 'pending',
+		})
+		expect(edits.count('tab')).toBe(0)
+	})
+
+	it('writes each row once with all its fields, and undoes with the old values', () => {
+		const edits = staged()
+		edits.stage('tab', { rowId: 'r1', field: 'a', before: 1, after: 2 })
+		edits.stage('tab', { rowId: 'r1', field: 'b', before: null, after: 'x' })
+		expect(edits.rowBody('tab', 'r1')).toEqual({ a: 2, b: 'x' })
+		expect(undoBodies(edits.list('tab')).get('r1')).toEqual({ a: 1, b: null })
+	})
+})
+
+describe('diagram history', () => {
+	it('squashes a burst of moves of one table into one step', () => {
+		const state = { positions: {}, notes: [] }
+		const history = new DiagramHistory()
+		history.push(
+			{
+				kind: 'tableMove',
+				tableName: 't',
+				from: { x: 0, y: 0 },
+				to: { x: 5, y: 0 },
+			},
+			1000,
+		)
+		history.push(
+			{
+				kind: 'tableMove',
+				tableName: 't',
+				from: { x: 5, y: 0 },
+				to: { x: 9, y: 0 },
+			},
+			1100,
+		)
+		expect(history.undo(state)).toBe(true)
+		expect(state.positions).toEqual({ t: { x: 0, y: 0 } })
+		expect(history.canUndo).toBe(false)
+		expect(history.redo(state)).toBe(true)
+		expect(state.positions).toEqual({ t: { x: 9, y: 0 } })
+	})
+})
+
+describe('query console helpers', () => {
+	const entry = (patch: Partial<HistoryEntry>): HistoryEntry => ({
+		id: '1',
+		userId: 'u',
+		query: {},
+		source: '',
+		language: 'aql',
+		executedAt: '2026-10-07T10:00:00.000Z',
+		durationMs: 10,
+		rowCount: 1,
+		status: 'ok',
+		mutation: false,
+		...patch,
+	})
+
+	it('tells runs apart', () => {
+		expect(runKind(entry({}))).toBe('fast')
+		expect(runKind(entry({ durationMs: 400 }))).toBe('slow')
+		expect(runKind(entry({ mutation: true }))).toBe('changed')
+		expect(runKind(entry({ status: 'error' }))).toBe('failed')
+	})
+
+	it('groups runs by day, newest first', () => {
+		const groups = groupByDay(
+			[
+				entry({ id: 'a', executedAt: '2026-10-07T10:00:00' }),
+				entry({ id: 'b', executedAt: '2026-10-06T10:00:00' }),
+			],
+			(run) => run.executedAt,
+		)
+		expect(groups.map((group) => group.items.map((run) => run.id))).toEqual([
+			['a'],
+			['b'],
+		])
+	})
+
+	it('reads the target of an encoded query', () => {
+		const encoded = {
+			__cls: 'Selection',
+			stages: [
+				{ stage: 'schema', options: { id: 'shop' }, args: [] },
+				{ stage: 'instance', options: { id: 'eu' }, args: [] },
+				{ stage: 'table', options: { id: 'orders' }, args: [] },
+			],
+		}
+		expect(readQueryTarget(encoded)).toEqual({
+			schema: 'shop',
+			instance: 'eu',
+			table: 'orders',
+		})
+	})
+
+	it('quotes CSV cells that need it', () => {
+		expect(
+			toCsv([
+				{ a: 'x,y', b: { c: 1 } },
+				{ a: null, d: 'say "hi"' },
+			]),
+		).toBe('a,b,d\n"x,y","{""c"":1}",\n,,"say ""hi"""\n')
+	})
+})
+
+describe('links', () => {
+	it('builds the DSL and page links of a table', () => {
+		expect(tableAccess({ schema: 'dms-core', table: 'users' })).toBe(
+			'schemas["dms-core"].instance().table("users")',
+		)
+		expect(
+			tableLink('data', {
+				schema: 'shop',
+				table: 'orders',
+				instance: 'eu',
+				match: { field: '_id', value: 'a:b' },
+			}),
+		).toBe(
+			'/modules/database/data?schema=shop&table=orders&instance=eu&match=_id%3Aa%3Ab',
+		)
+		expect(decodeMatch('_id:a:b')).toEqual({ field: '_id', value: 'a:b' })
+		expect(decodeMatch('nope')).toBeNull()
+	})
+})

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

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import {
+	PICKER_LIMIT,
+	matchNames,
+	sortNames,
+} from '../app/build/data/instanceOptions'
+
+describe('instance picker', () => {
+	it('sorts instances by name, numbers in order, once each', () => {
+		expect(sortNames(['us', 'tenant-10', 'eu', 'tenant-9', 'eu'])).toEqual([
+			'eu',
+			'tenant-9',
+			'tenant-10',
+			'us',
+		])
+	})
+
+	it('lists every instance without a search', () => {
+		expect(matchNames(['eu', 'us'], '  ')).toEqual({
+			shown: ['eu', 'us'],
+			total: 2,
+		})
+	})
+
+	it('matches a part of the name, whatever the case', () => {
+		const sorted = sortNames(['acme-EU', 'acme-us', 'globex-eu'])
+		expect(matchNames(sorted, 'Eu')).toEqual({
+			shown: ['acme-EU', 'globex-eu'],
+			total: 2,
+		})
+		expect(matchNames(sorted, 'initech')).toEqual({ shown: [], total: 0 })
+	})
+
+	it('renders a bounded slice of many instances and counts the rest', () => {
+		const sorted = sortNames(
+			Array.from({ length: 1_500 }, (_, index) => `tenant-${index}`),
+		)
+		const all = matchNames(sorted, '')
+		expect(all.shown).toHaveLength(PICKER_LIMIT)
+		expect(all.total).toBe(1_500)
+		expect(all.shown[0]).toBe('tenant-0')
+
+		const some = matchNames(sorted, 'tenant-14', 5)
+		expect(some.shown).toEqual([
+			'tenant-14',
+			'tenant-140',
+			'tenant-141',
+			'tenant-142',
+			'tenant-143',
+		])
+		expect(some.total).toBe(111)
+	})
+})

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

@@ -0,0 +1,56 @@
+import { readdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { baseCompile } from '@intlify/message-compiler'
+import { describe, expect, it } from 'vitest'
+
+// vue-i18n compiles a message the first time it shows it: a stray `@`, `{`,
+// `}` or `|` then fails at runtime, on the page that shows it (S-1). Compile
+// every message of every locale here instead; literals go through `{'@'}`.
+
+const LOCALES_DIR = join(import.meta.dirname, '../i18n/locales')
+
+type Messages = { [key: string]: string | Messages }
+
+function leaves(messages: Messages, prefix = ''): [string, string][] {
+	return Object.entries(messages).flatMap(([key, value]) => {
+		const path = prefix ? `${prefix}.${key}` : key
+		return typeof value === 'string' ? [[path, value]] : leaves(value, path)
+	})
+}
+
+function compileErrors(message: string): string[] {
+	const errors: string[] = []
+	baseCompile(message, {
+		onError: (error) => errors.push(error.message),
+		onWarn: () => undefined,
+	})
+	return errors
+}
+
+const files = readdirSync(LOCALES_DIR).filter((file) => file.endsWith('.json'))
+
+describe('locale messages', () => {
+	it('finds the locale files', () => {
+		expect(files.length).toBeGreaterThan(0)
+	})
+
+	it.each(files)('compiles every message of %s', (file) => {
+		const messages = JSON.parse(
+			readFileSync(join(LOCALES_DIR, file), 'utf8'),
+		) as Messages
+		const failures = leaves(messages)
+			.map(([key, message]) => ({ key, errors: compileErrors(message) }))
+			.filter((entry) => entry.errors.length > 0)
+			.map((entry) => `${entry.key}: ${entry.errors.join(', ')}`)
+		expect(failures).toEqual([])
+	})
+
+	it('reports an unescaped linked-message sign', () => {
+		expect(compileErrors('declares tables with @RegisterTable.')).not.toEqual(
+			[],
+		)
+		expect(compileErrors("declares tables with {'@'}RegisterTable.")).toEqual(
+			[],
+		)
+	})
+})

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

@@ -1,6 +1,6 @@
-import { afterEach, expect, it, vi } from 'vitest'
-import { computed, ref } from 'vue'
-import { useDataBrowserTabs } from '../app/composables/useDataBrowserTabs'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { computed, reactive, ref } from 'vue'
+import { useDataBrowserTabs } from '../app/build/composables/useDataBrowserTabs'
 
 afterEach(() => vi.unstubAllGlobals())
 
@@ -57,7 +57,12 @@ it('does not revisit an already selected deep link while restoring tabs', () =>
 	const replace = vi.fn()
 	vi.stubGlobal('useDmsRouter', () => ({ replace }))
 	vi.stubGlobal('useDmsRoute', () => ({
-		query: { schema: 'sales', table: 'orders', instance: 'eu', panel: 'detail' },
+		query: {
+			schema: 'sales',
+			table: 'orders',
+			instance: 'eu',
+			panel: 'detail',
+		},
 	}))
 	const browser = useDataBrowserTabs()
 	browser.restore()
@@ -65,6 +70,102 @@ it('does not revisit an already selected deep link while restoring tabs', () =>
 	expect(replace).not.toHaveBeenCalled()
 	browser.openTab('sales', 'us', 'orders', false)
 	expect(replace).toHaveBeenCalledExactlyOnceWith({
-		query: { schema: 'sales', table: 'orders', instance: 'us', panel: 'detail' },
+		query: {
+			schema: 'sales',
+			table: 'orders',
+			instance: 'us',
+			panel: 'detail',
+		},
+	})
+})
+
+it('restores the preview tab as a preview, the URL naming it included', () => {
+	setup()
+	const replace = vi.fn()
+	vi.stubGlobal('useDmsRouter', () => ({ replace }))
+	vi.stubGlobal('useDmsRoute', () => ({
+		query: { schema: 'sales', table: 'orders', instance: 'eu' },
+	}))
+	vi.stubGlobal('window', {
+		sessionStorage: {
+			getItem: () =>
+				JSON.stringify({
+					tabs: [
+						{ schema: 'sales', instance: 'eu', table: 'customers' },
+						{
+							schema: 'sales',
+							instance: 'eu',
+							table: 'orders',
+							preview: true,
+						},
+					],
+					activeId: 'sales::eu::orders',
+				}),
+			setItem: vi.fn(),
+		},
+	})
+	const browser = useDataBrowserTabs()
+	browser.restore()
+	expect(browser.activeId.value).toBe('sales::eu::orders')
+	expect(browser.tabs.value.map((tab) => tab.preview)).toEqual([false, true])
+	expect(replace).not.toHaveBeenCalled()
+})
+
+describe('data browser: the route it writes itself', () => {
+	// A reactive route the router writes to, as the DMS's stable
+	// useDmsRoute() reflects a landed visit.
+	function routed(query: Record<string, string> = {}) {
+		setup()
+		vi.stubGlobal('window', {
+			sessionStorage: { getItem: () => null, setItem: vi.fn() },
+		})
+		const route = reactive({ query })
+		const replace = vi.fn(({ query: next }: { query: typeof query }) => {
+			route.query = next
+		})
+		vi.stubGlobal('useDmsRoute', () => route)
+		vi.stubGlobal('useDmsRouter', () => ({ replace }))
+		return { route, replace, browser: useDataBrowserTabs() }
+	}
+
+	it('keeps a preview tab a preview once its URL lands', () => {
+		const { route, replace, browser } = routed()
+		browser.openTab('sales', 'eu', 'orders')
+		expect(replace).toHaveBeenCalledExactlyOnceWith({
+			query: { schema: 'sales', table: 'orders', instance: 'eu' },
+		})
+		// The page's route watcher sees the URL the browser wrote.
+		expect(route.query.table).toBe('orders')
+		expect(browser.openFromRoute()).toBe(true)
+		expect(browser.tabs.value).toEqual([
+			expect.objectContaining({ id: 'sales::eu::orders', preview: true }),
+		])
+	})
+
+	it('opens a linked table pinned, the preview slot left alone', () => {
+		const { route, browser } = routed()
+		browser.openTab('sales', 'eu', 'orders')
+		route.query = { schema: 'sales', table: 'customers', instance: 'eu' }
+		browser.openFromRoute()
+		expect(browser.activeId.value).toBe('sales::eu::customers')
+		expect(browser.tabs.value.map((tab) => [tab.id, tab.preview])).toEqual([
+			['sales::eu::orders', true],
+			['sales::eu::customers', false],
+		])
+	})
+
+	it('pins the active preview tab when a link filters it on a row', () => {
+		const { route, browser } = routed()
+		browser.openTab('sales', 'eu', 'orders')
+		route.query = {
+			schema: 'sales',
+			table: 'orders',
+			instance: 'eu',
+			match: '_id:42',
+		}
+		browser.openFromRoute()
+		expect(browser.tabs.value).toEqual([
+			expect.objectContaining({ id: 'sales::eu::orders', preview: false }),
+		])
 	})
 })

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

@@ -0,0 +1,254 @@
+import { describe, expect, it } from 'vitest'
+import {
+	CROSS_INSTANCE_VALUE,
+	DEFAULT_INSTANCE_VALUE,
+	instanceChoiceOf,
+	tabInstanceOf,
+} from '../app/build/composables/useDataBrowserTabs'
+import {
+	PICK_ALL,
+	PICK_DEFAULT,
+	instanceMenu,
+	instancePickChoice,
+	instancePickValue,
+	schemaMenu,
+	type InstanceMenu,
+	type PickerItem,
+} from '../app/build/data/pickerMenus'
+import { sortNames } from '../app/build/data/instanceOptions'
+
+// The schema and instance pickers the Schemas page's filter bar and the data
+// browser's sidebar share (SchemaPicker.vue, InstancePicker.vue).
+
+const values = (groups: PickerItem[][]) =>
+	groups.map((group) => group.map((item) => item.value ?? `#${item.label}`))
+
+const schemaLabels = {
+	more: (shown: number, total: number) => `First ${shown} of ${total}`,
+}
+
+describe('schema picker menu', () => {
+	const ids = sortNames(['shop', 'demo', 'core'])
+
+	it('pins "All schemas" first when the page lists every schema', () => {
+		const groups = schemaMenu({
+			ids,
+			search: '',
+			allLabel: 'All schemas',
+			...schemaLabels,
+		})
+		expect(values(groups)).toEqual([[PICK_ALL], ['core', 'demo', 'shop']])
+		expect(groups[0]?.[0]?.class).toBe('pin-top')
+	})
+
+	it('offers no "All schemas" when a schema is required', () => {
+		expect(
+			values(
+				schemaMenu({
+					ids,
+					search: '',
+					allLabel: null,
+					...schemaLabels,
+				}),
+			),
+		).toEqual([['core', 'demo', 'shop']])
+	})
+
+	it('searches every schema', () => {
+		expect(
+			values(
+				schemaMenu({
+					ids,
+					search: 'o',
+					allLabel: null,
+					...schemaLabels,
+				}),
+			),
+		).toEqual([['core', 'demo', 'shop']])
+	})
+
+	it('says how many matched beyond the ones listed', () => {
+		const many = sortNames(
+			Array.from({ length: 150 }, (_, index) => `module-${index}`),
+		)
+		const groups = schemaMenu({
+			ids: many,
+			search: '',
+			allLabel: null,
+			...schemaLabels,
+		})
+		expect(groups[0]?.at(-1)).toEqual({
+			label: 'First 100 of 150',
+			type: 'label',
+		})
+	})
+})
+
+function menu(overrides: Partial<InstanceMenu>): InstanceMenu {
+	return {
+		search: '',
+		hasSchema: true,
+		names: [],
+		matched: 0,
+		total: null,
+		status: 'idle',
+		allMode: 'filter',
+		labels: {
+			all: 'All instances',
+			readOnly: 'Read-only view',
+			default: 'default',
+			pickSchema: 'Pick a schema',
+			loading: 'Loading',
+			failed: 'Failed',
+			noNamed: 'No named instance',
+			noMatch: 'No instance matches',
+			more: (shown, total) => `First ${shown} of ${total}`,
+			count: (value) => String(value),
+		},
+		...overrides,
+	}
+}
+
+describe('instance picker menu', () => {
+	it('pins every instance, counted, and default first as a filter', () => {
+		const groups = instanceMenu(
+			menu({ names: ['eu', 'us'], matched: 2, total: 2, status: 'success' }),
+		)
+		expect(values(groups)).toEqual([
+			[PICK_ALL, PICK_DEFAULT],
+			['eu', 'us'],
+		])
+		expect(groups[0]?.[0]).toMatchObject({
+			label: 'All instances (3)',
+			icon: 'i-ph-stack-simple',
+			class: 'pin-top',
+		})
+	})
+
+	it('offers every instance first, locked, as the read-only view', () => {
+		const groups = instanceMenu(
+			menu({
+				names: ['eu'],
+				matched: 1,
+				total: 1,
+				status: 'success',
+				allMode: 'readonly',
+			}),
+		)
+		expect(values(groups)).toEqual([[PICK_ALL, PICK_DEFAULT], ['eu']])
+		expect(groups[0]?.[0]).toMatchObject({
+			label: 'All instances (2)',
+			description: 'Read-only view',
+			icon: 'i-ph-lock-simple',
+			class: 'pin-top',
+		})
+	})
+
+	it('keeps the read-only view after the matches of a search', () => {
+		const groups = instanceMenu(
+			menu({
+				search: 'zz',
+				total: 4,
+				status: 'success',
+				allMode: 'readonly',
+			}),
+		)
+		expect(values(groups)).toEqual([['#No instance matches'], [PICK_ALL]])
+		expect(groups[1]?.[0]?.class).toBeUndefined()
+		expect(
+			values(
+				instanceMenu(
+					menu({
+						search: 'e',
+						names: ['eu'],
+						matched: 1,
+						total: 4,
+						status: 'success',
+						allMode: 'readonly',
+					}),
+				),
+			),
+		).toEqual([[PICK_DEFAULT], ['eu'], [PICK_ALL]])
+	})
+
+	it('lists the "all" filter after the matches, or drops it', () => {
+		expect(
+			values(
+				instanceMenu(
+					menu({
+						search: 'all',
+						names: ['ball'],
+						matched: 1,
+						status: 'success',
+					}),
+				),
+			),
+		).toEqual([['ball'], [PICK_ALL]])
+	})
+
+	it('drops the "all" filter a search does not match', () => {
+		expect(
+			values(
+				instanceMenu(
+					menu({ search: 'eu', names: ['eu'], matched: 1, status: 'success' }),
+				),
+			),
+		).toEqual([['eu']])
+	})
+
+	it('says the instances load, failed, or are more than listed', () => {
+		expect(values(instanceMenu(menu({ status: 'pending' })))[1]).toEqual([
+			'#Loading',
+		])
+		expect(values(instanceMenu(menu({ status: 'error' })))[1]).toEqual([
+			'#Failed',
+		])
+		expect(
+			values(
+				instanceMenu(
+					menu({ status: 'success', total: 0, matched: 0, names: [] }),
+				),
+			)[1],
+		).toEqual(['#No named instance'])
+		expect(
+			values(
+				instanceMenu(
+					menu({
+						status: 'success',
+						names: ['tenant-1'],
+						matched: 500,
+						total: 500,
+					}),
+				),
+			)[1],
+		).toEqual(['tenant-1', '#First 1 of 500'])
+	})
+
+	it('asks for a schema before listing named instances', () => {
+		for (const allMode of ['filter', 'readonly'] as const)
+			expect(values(instanceMenu(menu({ hasSchema: false, allMode })))).toEqual(
+				[[PICK_ALL, PICK_DEFAULT], ['#Pick a schema']],
+			)
+	})
+
+	it('maps choices to menu values and back', () => {
+		for (const choice of [
+			{ kind: 'all' },
+			{ kind: 'default' },
+			{ kind: 'named', id: 'eu' },
+		] as const)
+			expect(instancePickChoice(instancePickValue(choice))).toEqual(choice)
+	})
+
+	it('maps a data-browser tab instance to a choice and back', () => {
+		for (const instance of [
+			DEFAULT_INSTANCE_VALUE,
+			CROSS_INSTANCE_VALUE,
+			'eu',
+			'all',
+		])
+			expect(tabInstanceOf(instanceChoiceOf(instance))).toBe(instance)
+		expect(instanceChoiceOf(CROSS_INSTANCE_VALUE)).toEqual({ kind: 'all' })
+		expect(instanceChoiceOf('all')).toEqual({ kind: 'named', id: 'all' })
+	})
+})