@antelopejs/dms-database 0.0.14 → 0.1.0

package/frontend-vue/app/build/data/cellValues.ts

@@ -0,0 +1,132 @@
+// How a typed draft becomes a cell value: the stored type is kept, and a
+// column whose cell is empty falls back to the type sampled for it, so filling
+// an empty cell of a number column stores a number. A date column takes a
+// date whatever its cell holds, as dates travel as ISO text.
+//
+// "null" empties a cell, whatever its type. The text "null" itself is typed
+// escaped, "\null" (and "\\null" for "\null"): an editor opens a cell holding
+// such a text escaped, so committing it unchanged keeps it.
+
+type DraftResult =
+	| { ok: true; value: unknown; unchanged: boolean }
+	| { ok: false; reason: 'number' | 'boolean' | 'date' }
+
+type Parser = (text: string) => DraftResult
+
+const BOOLEANS: Record<string, boolean> = { true: true, false: false }
+const NULL_DRAFT = 'null'
+// A text made of backslashes then "null": typed with one more backslash.
+const NULL_LIKE_TEXT = /^\\*null$/
+const ESCAPED_NULL = /^\\+null$/
+// YYYY-MM-DD, then optionally a time (T or a space) and a zone.
+const DATE_DRAFT =
+	/^(\d{4})-(\d{2})-(\d{2})(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/i
+
+function parsed(value: unknown): DraftResult {
+	return { ok: true, value, unchanged: false }
+}
+
+// Date.parse rolls an impossible day over (2026-02-30 is March 2nd): the
+// calendar date typed must exist.
+function isCalendarDate(year: number, month: number, day: number): boolean {
+	const date = new Date(Date.UTC(year, month - 1, day))
+	return (
+		date.getUTCFullYear() === year &&
+		date.getUTCMonth() === month - 1 &&
+		date.getUTCDate() === day
+	)
+}
+
+function parseDate(text: string): DraftResult {
+	const trimmed = text.trim()
+	const match = DATE_DRAFT.exec(trimmed)
+	const time = match ? Date.parse(trimmed) : Number.NaN
+	if (
+		!match ||
+		Number.isNaN(time) ||
+		!isCalendarDate(Number(match[1]), Number(match[2]), Number(match[3]))
+	)
+		return { ok: false, reason: 'date' }
+	return parsed(new Date(time).toISOString())
+}
+
+const PARSERS: Record<string, Parser> = {
+	number: (text) => {
+		const trimmed = text.trim()
+		const value = Number(trimmed)
+		return trimmed === '' || !Number.isFinite(value)
+			? { ok: false, reason: 'number' }
+			: parsed(value)
+	},
+	boolean: (text) => {
+		const value = BOOLEANS[text.trim().toLowerCase()]
+		return value === undefined
+			? { ok: false, reason: 'boolean' }
+			: parsed(value)
+	},
+	date: parseDate,
+}
+
+function isEmpty(value: unknown): boolean {
+	return value === null || value === undefined
+}
+
+/** The value a draft stands for, given the cell's current value and column type. */
+export function parseDraft(
+	draft: string | boolean,
+	before: unknown,
+	columnType: string,
+): DraftResult {
+	if (typeof draft === 'boolean')
+		return { ok: true, value: draft, unchanged: draft === before }
+	if (draft.trim() === NULL_DRAFT)
+		return { ok: true, value: null, unchanged: isEmpty(before) }
+	// Leaving an empty cell empty is not an edit.
+	if (isEmpty(before) && draft === '')
+		return { ok: true, value: before, unchanged: true }
+	const text = ESCAPED_NULL.test(draft) ? draft.slice(1) : draft
+	const type =
+		columnType === 'date'
+			? 'date'
+			: isEmpty(before)
+				? columnType
+				: typeof before
+	const result = (PARSERS[type] ?? parsed)(text)
+	if (!result.ok) return result
+	return {
+		...result,
+		unchanged: !isEmpty(before) && String(before) === String(result.value),
+	}
+}
+
+/** The text an editor opens a cell with: see the escape above. */
+export function draftText(value: unknown): string {
+	if (typeof value === 'string' && NULL_LIKE_TEXT.test(value))
+		return `\\${value}`
+	return cellText(value)
+}
+
+/** A cell as one line of text: JSON for objects and lists. */
+export function cellText(value: unknown): string {
+	if (isEmpty(value)) return ''
+	if (typeof value !== 'object') return String(value)
+	try {
+		return JSON.stringify(value)
+	} catch {
+		return String(value)
+	}
+}
+
+/**
+ * A cell as the review and the "was" hints name it: an empty cell reads
+ * null, and a text that would read as one of those is quoted ("", "null").
+ */
+export function cellLabel(value: unknown): string {
+	if (isEmpty(value)) return NULL_DRAFT
+	if (value === '' || value === NULL_DRAFT) return JSON.stringify(value)
+	return cellText(value)
+}
+
+export function isStructured(value: unknown): boolean {
+	return value !== null && typeof value === 'object'
+}

package/frontend-vue/app/build/data/instanceOptions.ts

@@ -0,0 +1,36 @@
+// The names a picker lists for a search: schema ids, or the named instances
+// of a schema. A SaaS schema can hold one instance per tenant, so a picker
+// renders at most `limit` of them and says how many matched.
+
+export const PICKER_LIMIT = 100
+
+/** Every instance, the default one, or a named one. */
+export type InstanceChoice =
+	| { kind: 'all' }
+	| { kind: 'default' }
+	| { kind: 'named'; id: string }
+
+const collator = new Intl.Collator(undefined, { numeric: true })
+
+/** Names in order, numbers by value, once each. */
+export function sortNames(names: readonly string[]): string[] {
+	return [...new Set(names)].sort(collator.compare)
+}
+
+interface NameMatches {
+	shown: string[]
+	total: number
+}
+
+/** Expects names already sorted; matches a name containing the search. */
+export function matchNames(
+	sorted: readonly string[],
+	search: string,
+	limit = PICKER_LIMIT,
+): NameMatches {
+	const needle = search.trim().toLowerCase()
+	const matches = needle
+		? sorted.filter((id) => id.toLowerCase().includes(needle))
+		: sorted
+	return { shown: matches.slice(0, limit), total: matches.length }
+}

package/frontend-vue/app/build/data/pickerMenus.ts

@@ -0,0 +1,175 @@
+import type { InstanceChoice } from './instanceOptions'
+import { matchNames } from './instanceOptions'
+
+// The menus of the schema and instance pickers (SchemaPicker.vue,
+// InstancePicker.vue), shared by the Schemas page's filter bar and the data
+// browser's sidebar: what is pinned, the names a search found, and the note
+// under them (loading, failed, more than shown).
+
+export interface PickerItem {
+	label: string
+	value?: string
+	icon?: string
+	description?: string
+	class?: string
+	type?: 'label'
+}
+
+// Menu values standing for no schema or instance in particular: a NUL never
+// appears in a name.
+export const PICK_ALL = '\u0000all'
+export const PICK_DEFAULT = '\u0000default'
+
+// A group holding a `.pin-top` item sticks to the top of the list while it
+// scrolls; notes read as plain text.
+export const PICKER_MENU_UI = {
+	viewport: 'scroll-pt-10 scroll-pb-14',
+	label: 'font-sans text-xs font-normal normal-case tracking-normal text-muted',
+	group:
+		'bg-default has-[.pin-top]:sticky has-[.pin-top]:top-0 has-[.pin-top]:z-10',
+}
+
+export const SCHEMA_ICON = 'i-ph-stack'
+export const ALL_ICON = 'i-ph-stack-simple'
+export const INSTANCE_ICON = 'i-ph-cube'
+export const READ_ONLY_ICON = 'i-ph-lock-simple'
+
+/**
+ * How a picker offers every instance: as a filter ("filter"), or as the data
+ * browser's read-only cross-instance view ("readonly").
+ */
+export type AllInstancesMode = 'filter' | 'readonly'
+
+function matching(label: string, needle: string): boolean {
+	return !needle || label.toLowerCase().includes(needle)
+}
+
+function groups(...lists: PickerItem[][]): PickerItem[][] {
+	return lists.filter((group) => group.length > 0)
+}
+
+interface SchemaMenu {
+	/** Schema ids, sorted. */
+	ids: readonly string[]
+	search: string
+	/** "All schemas", pinned first; null when a schema must be picked. */
+	allLabel: string | null
+	more: (shown: number, total: number) => string
+}
+
+export function schemaMenu(menu: SchemaMenu): PickerItem[][] {
+	const needle = menu.search.trim().toLowerCase()
+	const pinned: PickerItem[] =
+		menu.allLabel !== null && matching(menu.allLabel, needle)
+			? [
+					{
+						label: menu.allLabel,
+						value: PICK_ALL,
+						icon: ALL_ICON,
+						class: 'pin-top',
+					},
+				]
+			: []
+	const { shown, total } = matchNames(menu.ids, menu.search)
+	const named: PickerItem[] = shown.map((id) => ({
+		label: id,
+		value: id,
+		icon: SCHEMA_ICON,
+	}))
+	if (total > shown.length)
+		named.push({ label: menu.more(shown.length, total), type: 'label' })
+	return groups(pinned, named)
+}
+
+export type InstancesStatus = 'idle' | 'pending' | 'success' | 'error'
+
+interface InstanceMenuLabels {
+	all: string
+	/** Under "all" in the read-only mode. */
+	readOnly: string
+	default: string
+	pickSchema: string
+	loading: string
+	failed: string
+	noNamed: string
+	noMatch: string
+	more: (shown: number, total: number) => string
+	count: (value: number) => string
+}
+
+export interface InstanceMenu {
+	search: string
+	/** A schema is picked: its named instances can be listed. */
+	hasSchema: boolean
+	/** Named instances the search found, at most the picker's limit. */
+	names: readonly string[]
+	/** Named instances matching the search. */
+	matched: number
+	/** Named instances of the schema, before any search; null until known. */
+	total: number | null
+	status: InstancesStatus
+	allMode: AllInstancesMode
+	labels: InstanceMenuLabels
+}
+
+export function instanceMenu(menu: InstanceMenu): PickerItem[][] {
+	const { labels } = menu
+	const needle = menu.search.trim().toLowerCase()
+	const readOnly = menu.allMode === 'readonly'
+	// Every instance: the default one and the named ones. The read-only view
+	// is offered whatever the search, as it also reads rows of instances never
+	// registered; the filter matches the search.
+	const all: PickerItem[] =
+		readOnly || matching(labels.all, needle)
+			? [
+					{
+						label:
+							menu.total === null
+								? labels.all
+								: `${labels.all} (${labels.count(menu.total + 1)})`,
+						value: PICK_ALL,
+						icon: readOnly ? READ_ONLY_ICON : ALL_ICON,
+						...(readOnly ? { description: labels.readOnly } : {}),
+						...(needle ? {} : { class: 'pin-top' }),
+					},
+				]
+			: []
+	const defaultShown = matching(labels.default, needle)
+	const pinned: PickerItem[] = defaultShown
+		? [{ label: labels.default, value: PICK_DEFAULT, icon: INSTANCE_ICON }]
+		: []
+	// Without a search "all" comes first, pinned; while one is typed it comes
+	// after the matches, so that Enter picks the first match.
+	if (!needle) pinned.unshift(...all)
+	const last = needle ? all : []
+	if (!menu.hasSchema)
+		return groups(pinned, [{ label: labels.pickSchema, type: 'label' }], last)
+	const named: PickerItem[] = menu.names.map((id) => ({
+		label: id,
+		value: id,
+		icon: INSTANCE_ICON,
+	}))
+	let note: string | null = null
+	if (menu.status === 'error') note = labels.failed
+	else if (menu.status !== 'success') note = labels.loading
+	else if (menu.total === 0 && !needle) note = labels.noNamed
+	else if (menu.matched === 0 && !defaultShown) note = labels.noMatch
+	else if (menu.matched > named.length)
+		note = labels.more(named.length, menu.matched)
+	if (note) named.push({ label: note, type: 'label' })
+	return groups(pinned, named, last)
+}
+
+/** A picker's menu value for an instance choice. */
+export function instancePickValue(choice: InstanceChoice): string {
+	if (choice.kind === 'all') return PICK_ALL
+	if (choice.kind === 'default') return PICK_DEFAULT
+	return choice.id
+}
+
+/** The instance choice a picker's menu value stands for. */
+export function instancePickChoice(value: string): InstanceChoice {
+	if (value === PICK_ALL) return { kind: 'all' }
+	if (value === PICK_DEFAULT) return { kind: 'default' }
+	return { kind: 'named', id: value }
+}

package/frontend-vue/app/build/data/recentTables.ts

@@ -0,0 +1,48 @@
+// The tables opened lately, offered by the data browser's first-visit state
+// (D-15). Kept in this browser only.
+
+export interface RecentTable {
+	schema: string
+	instance: string
+	table: string
+	openedAt: string
+}
+
+const STORAGE_KEY = 'dms-database:data-browser:recent'
+const MAX_RECENT = 5
+
+export function readRecentTables(): RecentTable[] {
+	if (typeof window === 'undefined') return []
+	try {
+		const parsed = JSON.parse(window.localStorage.getItem(STORAGE_KEY) ?? '[]')
+		return Array.isArray(parsed)
+			? parsed.filter(
+					(entry): entry is RecentTable =>
+						typeof entry?.schema === 'string' &&
+						typeof entry?.table === 'string' &&
+						typeof entry?.instance === 'string',
+				)
+			: []
+	} catch {
+		return []
+	}
+}
+
+export function rememberTable(entry: Omit<RecentTable, 'openedAt'>) {
+	if (typeof window === 'undefined') return
+	const others = readRecentTables().filter(
+		(recent) =>
+			recent.schema !== entry.schema ||
+			recent.table !== entry.table ||
+			recent.instance !== entry.instance,
+	)
+	const next = [
+		{ ...entry, openedAt: new Date().toISOString() },
+		...others,
+	].slice(0, MAX_RECENT)
+	try {
+		window.localStorage.setItem(STORAGE_KEY, JSON.stringify(next))
+	} catch {
+		// A full or private storage only loses the suggestions.
+	}
+}

package/frontend-vue/app/build/data/stagedEdits.ts

@@ -0,0 +1,117 @@
+// Edits of the data browser are staged (D-02): a changed cell keeps its old
+// value until the user saves, and a save can be undone for a few seconds.
+// Staged edits live per tab, keyed by row id then column, and survive
+// switching tabs.
+
+export interface StagedCell {
+	before: unknown
+	after: unknown
+}
+
+/** One staged change, as the review lists it. */
+export interface StagedChange extends StagedCell {
+	rowId: string
+	field: string
+}
+
+type RowEdits = Record<string, StagedCell>
+type TabEdits = Record<string, RowEdits>
+
+/** Two cell values are the same when their JSON forms are. */
+function sameValue(left: unknown, right: unknown): boolean {
+	if (left === right) return true
+	try {
+		return JSON.stringify(left ?? null) === JSON.stringify(right ?? null)
+	} catch {
+		return false
+	}
+}
+
+export function useStagedEdits() {
+	const edits = useDmsState<Record<string, TabEdits>>(
+		'dms-database-staged-edits',
+		() => ({}),
+	)
+
+	function tabEdits(tabId: string): TabEdits {
+		return edits.value[tabId] ?? {}
+	}
+
+	function get(
+		tabId: string,
+		rowId: string,
+		field: string,
+	): StagedCell | undefined {
+		return tabEdits(tabId)[rowId]?.[field]
+	}
+
+	/** Stages `after` over `before`; setting a cell back to `before` unstages it. */
+	function stage(tabId: string, change: StagedChange) {
+		const rows = { ...tabEdits(tabId) }
+		const row = { ...(rows[change.rowId] ?? {}) }
+		const before = row[change.field]?.before ?? change.before
+		if (sameValue(before, change.after))
+			Reflect.deleteProperty(row, change.field)
+		else row[change.field] = { before, after: change.after }
+		if (Object.keys(row).length === 0)
+			Reflect.deleteProperty(rows, change.rowId)
+		else rows[change.rowId] = row
+		edits.value = { ...edits.value, [tabId]: rows }
+	}
+
+	function list(tabId: string): StagedChange[] {
+		return Object.entries(tabEdits(tabId)).flatMap(([rowId, row]) =>
+			Object.entries(row).map(([field, cell]) => ({ rowId, field, ...cell })),
+		)
+	}
+
+	function count(tabId: string): number {
+		return list(tabId).length
+	}
+
+	function rowCount(tabId: string, rowId: string): number {
+		return Object.keys(tabEdits(tabId)[rowId] ?? {}).length
+	}
+
+	function discard(tabId: string, rowIds?: string[]) {
+		if (!rowIds) {
+			const next = { ...edits.value }
+			Reflect.deleteProperty(next, tabId)
+			edits.value = next
+			return
+		}
+		const rows = { ...tabEdits(tabId) }
+		for (const rowId of rowIds) Reflect.deleteProperty(rows, rowId)
+		edits.value = { ...edits.value, [tabId]: rows }
+	}
+
+	/** The staged values of a row, as the edit route takes them. */
+	function rowBody(tabId: string, rowId: string): Record<string, unknown> {
+		return Object.fromEntries(
+			Object.entries(tabEdits(tabId)[rowId] ?? {}).map(([field, cell]) => [
+				field,
+				cell.after,
+			]),
+		)
+	}
+
+	function rowIds(tabId: string): string[] {
+		return Object.keys(tabEdits(tabId))
+	}
+
+	return { get, stage, list, count, rowCount, discard, rowBody, rowIds }
+}
+
+/** The values a saved change replaced, grouped per row: what an undo writes. */
+export function undoBodies(
+	changes: StagedChange[],
+): Map<string, Record<string, unknown>> {
+	const bodies = new Map<string, Record<string, unknown>>()
+	for (const change of changes) {
+		const body = bodies.get(change.rowId) ?? {}
+		// An empty cell is cleared with null: the edit route skips undefined.
+		body[change.field] = change.before ?? null
+		bodies.set(change.rowId, body)
+	}
+	return bodies
+}

package/frontend-vue/app/build/data/stagedWrites.ts

@@ -0,0 +1,64 @@
+// Writes rows one call at a time, as a save and its undo do, and tells what
+// went through: the rows written, the rows gone meanwhile (404, nothing left
+// to write to) and the error that stopped the rest, if any. Rows are written
+// in order and the first other failure stops the run, so the rows after it
+// are left untouched.
+
+const NOT_FOUND = 404
+
+export interface RowWriteOutcome {
+	written: string[]
+	gone: string[]
+	/** The failure that stopped the run; its row and the next ones are left. */
+	error: unknown
+	/** The rows neither written nor gone, in order. */
+	left: string[]
+}
+
+function statusOf(error: unknown): number | undefined {
+	const failure = error as { statusCode?: number; status?: number } | null
+	return failure?.statusCode ?? failure?.status
+}
+
+export async function writeRows(
+	rows: Iterable<[string, Record<string, unknown>]>,
+	write: (rowId: string, body: Record<string, unknown>) => Promise<unknown>,
+	/** Called once a row is settled: written, or gone. */
+	onSettled?: (rowId: string) => void,
+): Promise<RowWriteOutcome> {
+	const outcome: RowWriteOutcome = {
+		written: [],
+		gone: [],
+		error: null,
+		left: [],
+	}
+	for (const [rowId, body] of rows) {
+		if (outcome.error !== null) {
+			outcome.left.push(rowId)
+			continue
+		}
+		try {
+			await write(rowId, body)
+			outcome.written.push(rowId)
+		} catch (error) {
+			if (statusOf(error) !== NOT_FOUND) {
+				// A failure without a message still stops the run.
+				outcome.error = error ?? new Error('Write failed')
+				outcome.left.push(rowId)
+				continue
+			}
+			outcome.gone.push(rowId)
+		}
+		onSettled?.(rowId)
+	}
+	return outcome
+}
+
+/** The changes of the rows given, in their order of the list. */
+export function changesOf<T extends { rowId: string }>(
+	changes: T[],
+	rowIds: string[],
+): T[] {
+	const rows = new Set(rowIds)
+	return changes.filter((change) => rows.has(change.rowId))
+}