@antelopejs/dms-database 0.0.14 → 0.1.1

package/frontend-vue/app/build/composables/useDatabaseHealth.ts

@@ -0,0 +1,50 @@
+interface StorageEntry {
+	schema: string
+	table: string
+	rows: number
+}
+
+interface OverviewHealth {
+	status: 'ok' | 'down'
+	latencyMs: number | null
+	driver: string | null
+	checkedAt: string | null
+	error: string | null
+	schemaCount: number
+	tableCount: number
+	relationCount: number
+	indexCount: number
+	totalRows: number
+	storage: StorageEntry[]
+}
+
+const HEALTH_ENDPOINT = '/api/database/health'
+
+const EMPTY_HEALTH: OverviewHealth = {
+	status: 'ok',
+	latencyMs: null,
+	driver: null,
+	checkedAt: null,
+	error: null,
+	schemaCount: 0,
+	tableCount: 0,
+	relationCount: 0,
+	indexCount: 0,
+	totalRows: 0,
+	storage: [],
+}
+
+export function useDatabaseHealth() {
+	const { useFetchAuth } = useAuthFetch()
+	const { data, pending, error, refresh } = useFetchAuth<OverviewHealth>(
+		HEALTH_ENDPOINT,
+		{ default: () => ({ ...EMPTY_HEALTH }) },
+	)
+
+	return {
+		health: computed(() => data.value ?? { ...EMPTY_HEALTH }),
+		isLoading: pending,
+		error,
+		refresh,
+	}
+}

package/frontend-vue/app/build/composables/useDatabaseSchemas.ts

@@ -0,0 +1,140 @@
+interface RelationDeclaration {
+	fromField: string
+	toSchema: string
+	toTable: string
+	toField: string
+	many: boolean
+}
+
+type FieldDescriptor =
+	| { kind: 'string' }
+	| { kind: 'number' }
+	| { kind: 'boolean' }
+	| { kind: 'date' }
+	| { kind: 'unknown' }
+	| { kind: 'any' }
+	| { kind: 'null' }
+	| { kind: 'undefined' }
+	| { kind: 'literal'; value: string | number | boolean }
+	| { kind: 'union'; members: FieldDescriptor[] }
+	| { kind: 'intersection'; members: FieldDescriptor[] }
+	| { kind: 'array'; element?: FieldDescriptor }
+	| { kind: 'tuple'; elements: FieldDescriptor[] }
+	| {
+			kind: 'object'
+			fields: Record<string, FieldDescriptor>
+			partial?: boolean
+	  }
+	| { kind: 'record'; key?: FieldDescriptor; value: FieldDescriptor }
+	| { kind: 'keyof'; keys: string[] }
+	| { kind: 'refinement'; base: FieldDescriptor; name: string }
+	| { kind: 'recursive'; name: string }
+
+interface TableSummary {
+	name: string
+	fields: Record<string, FieldDescriptor>
+	indexes: Record<string, { fields?: string[]; multi?: boolean }>
+	relations: RelationDeclaration[]
+	modifiers?: Record<string, string[]>
+}
+
+type SchemaLabelColor =
+	| 'primary'
+	| 'secondary'
+	| 'success'
+	| 'info'
+	| 'warning'
+	| 'error'
+	| 'neutral'
+
+/** A relation seen from the table it points to. */
+interface InboundRelation extends RelationDeclaration {
+	fromSchema: string
+	fromTable: string
+}
+
+interface SchemaLabel {
+	text: string
+	color?: SchemaLabelColor
+}
+
+interface SchemaStats {
+	tableCount: number
+	elementCount: number
+	instanceCount: number
+}
+
+interface SchemaSummary {
+	id: string
+	options: Record<string, never>
+	tables: TableSummary[]
+	label?: SchemaLabel
+	stats: SchemaStats
+	instances: string[]
+}
+
+const SCHEMAS_ENDPOINT = '/api/database/schemas'
+const EMPTY_SCHEMAS = { schemas: [] as SchemaSummary[] }
+
+/** A table of the given schemas, by schema id and table name. */
+export function findTableIn(
+	schemas: SchemaSummary[],
+	schemaId: string,
+	tableName: string,
+): TableSummary | undefined {
+	return schemas
+		.find((schema) => schema.id === schemaId)
+		?.tables.find((table) => table.name === tableName)
+}
+
+/** Relations of every table that point at `schemaId.tableName`. */
+export function inboundRelationsIn(
+	schemas: SchemaSummary[],
+	schemaId: string,
+	tableName: string,
+): InboundRelation[] {
+	return schemas.flatMap((schema) =>
+		schema.tables.flatMap((table) =>
+			table.relations
+				.filter(
+					(relation) =>
+						relation.toSchema === schemaId && relation.toTable === tableName,
+				)
+				.map((relation) => ({
+					...relation,
+					fromSchema: schema.id,
+					fromTable: table.name,
+				})),
+		),
+	)
+}
+
+export function useDatabaseSchemas() {
+	const { useFetchAuth } = useAuthFetch()
+	const { data, pending, error, status, refresh } = useFetchAuth<{
+		schemas: SchemaSummary[]
+	}>(SCHEMAS_ENDPOINT, { default: () => EMPTY_SCHEMAS })
+
+	const schemas = computed(() => data.value?.schemas ?? [])
+
+	return {
+		schemas,
+		findTable: (schemaId: string, tableName: string) =>
+			findTableIn(schemas.value, schemaId, tableName),
+		isLoading: pending,
+		/** The schemas arrived, or failed to: the list is what there is. */
+		isSettled: computed(
+			() => status.value === 'success' || status.value === 'error',
+		),
+		error,
+		refresh,
+	}
+}
+
+export type {
+	FieldDescriptor,
+	InboundRelation,
+	RelationDeclaration,
+	SchemaSummary,
+	TableSummary,
+}

package/frontend-vue/app/{composables → build/composables}/useDiagramPersistence.ts

@@ -1,47 +1,51 @@
 export interface DiagramPosition {
-	x: number;
-	y: number;
+	x: number
+	y: number
 }
 
-export type DiagramPositions = Record<string, DiagramPosition>;
+export type DiagramPositions = Record<string, DiagramPosition>
 
 export interface DiagramNote {
-	id: string;
-	schemaName: string;
-	text: string;
-	x: number;
-	y: number;
-	width: number;
-	height: number;
-	color: string | null;
-	createdAt: string;
-	updatedAt: string;
+	id: string
+	schemaName: string
+	text: string
+	x: number
+	y: number
+	width: number
+	height: number
+	color: string | null
+	createdAt: string
+	updatedAt: string
 }
 
 export interface DiagramNoteCreate {
-	schemaName: string;
-	text: string;
-	x: number;
-	y: number;
-	width: number;
-	height: number;
-	color?: string;
+	schemaName: string
+	text: string
+	x: number
+	y: number
+	width: number
+	height: number
+	color?: string
 }
 
 export type DiagramNoteUpdate = Partial<
-	Pick<DiagramNote, "text" | "x" | "y" | "width" | "height" | "color">
->;
+	Pick<DiagramNote, 'text' | 'x' | 'y' | 'width' | 'height' | 'color'>
+>
 
-const BASE = "/api/database/diagram";
+const BASE = '/api/database/diagram'
+// A request that hangs fails after this (ofetch's own `timeout`), so the
+// canvas shows the error and its "Try again" instead of "Saving…" forever.
+const REQUEST_TIMEOUT_MS = 15_000
 
 export function useDiagramPersistence() {
-	const { $authFetch } = useAuthFetch();
+	const { $authFetch } = useAuthFetch()
 
 	async function fetchLayout(schema: string): Promise<DiagramPositions> {
 		const res = await $authFetch<{ positions: DiagramPositions }>(
 			`${BASE}/layout/${encodeURIComponent(schema)}`,
-		);
-		return res.positions ?? {};
+			{ timeout: REQUEST_TIMEOUT_MS },
+		)
+		return res.positions ?? {}
 	}
 
 	async function saveLayout(
@@ -51,41 +55,45 @@ export function useDiagramPersistence() {
 		await $authFetch<{ success: boolean }>(
 			`${BASE}/layout/${encodeURIComponent(schema)}`,
 			{
-				method: "PUT",
+				method: 'PUT',
 				body: { positions },
+				timeout: REQUEST_TIMEOUT_MS,
 			},
-		);
+		)
 	}
 
 	async function fetchNotes(schema: string): Promise<DiagramNote[]> {
 		const res = await $authFetch<{ items: DiagramNote[] }>(`${BASE}/notes`, {
 			query: { schema },
-		});
-		return res.items ?? [];
+			timeout: REQUEST_TIMEOUT_MS,
+		})
+		return res.items ?? []
 	}
 
 	async function createNote(payload: DiagramNoteCreate): Promise<DiagramNote> {
 		return $authFetch<DiagramNote>(`${BASE}/notes`, {
-			method: "POST",
+			method: 'POST',
 			body: payload,
-		});
+			timeout: REQUEST_TIMEOUT_MS,
+		})
 	}
 
 	async function updateNote(
 		id: string,
 		patch: DiagramNoteUpdate,
 	): Promise<DiagramNote> {
-		return $authFetch<DiagramNote>(
-			`${BASE}/notes/${encodeURIComponent(id)}`,
-			{ method: "PUT", body: patch },
-		);
+		return $authFetch<DiagramNote>(`${BASE}/notes/${encodeURIComponent(id)}`, {
+			method: 'PUT',
+			body: patch,
+			timeout: REQUEST_TIMEOUT_MS,
+		})
 	}
 
 	async function deleteNote(id: string): Promise<void> {
 		await $authFetch<{ success: boolean }>(
 			`${BASE}/notes/${encodeURIComponent(id)}`,
-			{ method: "DELETE" },
-		);
+			{ method: 'DELETE', timeout: REQUEST_TIMEOUT_MS },
+		)
 	}
 
 	return {
@@ -95,5 +103,5 @@ export function useDiagramPersistence() {
 		createNote,
 		updateNote,
 		deleteNote,
-	};
+	}
 }

package/frontend-vue/app/build/composables/useQueryRuntime.ts

@@ -0,0 +1,217 @@
+import {
+	CROSS_INSTANCE,
+	Datum,
+	Query,
+	Schema,
+	SchemaInstance,
+	Selection,
+	SingleSelection,
+	Stream,
+	Table,
+	ValueProxy,
+} from '@antelopejs/interface-database/staged-query'
+import { javascriptLanguage } from '@codemirror/lang-javascript'
+import { containsMutations, encodeStaged } from '../utils/stagedSerialization'
+import type { SchemaSummary } from './useDatabaseSchemas'
+
+interface PreparedQuery {
+	query: Record<string, unknown>
+	source: string
+	hasMutations: boolean
+}
+
+interface SchemaDefLike {
+	[tableName: string]: { fields: unknown; indexes: unknown }
+}
+
+/** Where a query text breaks (1-based line and column). */
+export interface SyntaxPlace {
+	line: number
+	column: number
+}
+
+export type QueryInputProblem =
+	| { kind: 'syntax'; place: SyntaxPlace | null; detail: string }
+	| { kind: 'unknown_schema'; schema: string }
+
+/**
+ * A query the console could not send, for a reason it can name: a syntax
+ * error with its place, or a schema the workspace does not have. The message
+ * is English; the console words it from `problem`.
+ */
+export class QueryInputError extends Error {
+	readonly problem: QueryInputProblem
+
+	constructor(message: string, problem: QueryInputProblem) {
+		super(message)
+		this.name = 'QueryInputError'
+		this.problem = problem
+	}
+}
+
+function toSchemaDefinition(summary: SchemaSummary): SchemaDefLike {
+	const def: SchemaDefLike = {}
+	for (const table of summary.tables) {
+		def[table.name] = {
+			fields: table.fields ?? {},
+			indexes: table.indexes ?? {},
+		}
+	}
+	return def
+}
+
+function buildSchemasMap(
+	summaries: SchemaSummary[],
+): Record<string, Schema<unknown, SchemaDefLike>> {
+	const bindings: Record<string, Schema<unknown, SchemaDefLike>> = {}
+	for (const summary of summaries) {
+		bindings[summary.id] =
+			Schema.get<unknown, SchemaDefLike>(summary.id) ??
+			new Schema(summary.id, toSchemaDefinition(summary))
+	}
+	return bindings
+}
+
+// Keys read off the schema map by the engine rather than by the query.
+const IGNORED_KEYS = new Set(['then', 'toJSON'])
+
+/** The schema map, naming an unknown schema instead of answering undefined. */
+function guardSchemas<T extends object>(
+	bindings: Record<string, T>,
+): Record<string, T> {
+	return new Proxy(bindings, {
+		get(target, key, receiver) {
+			if (
+				typeof key === 'string' &&
+				!(key in target) &&
+				!IGNORED_KEYS.has(key)
+			) {
+				throw new QueryInputError(`Unknown schema "${key}"`, {
+					kind: 'unknown_schema',
+					schema: key,
+				})
+			}
+			return Reflect.get(target, key, receiver)
+		},
+	})
+}
+
+/**
+ * Where the JavaScript parser of the editor stops on a query text: the first
+ * error node of its tree; null when it parses.
+ */
+export function findSyntaxPlace(text: string): SyntaxPlace | null {
+	let at: number | null = null
+	javascriptLanguage.parser.parse(text).iterate({
+		enter(node) {
+			if (at !== null) return false
+			if (!node.type.isError) return undefined
+			at = node.from
+			return false
+		},
+	})
+	if (at === null) return null
+	const before = text.slice(0, at)
+	return {
+		line: before.split('\n').length,
+		column: at - before.lastIndexOf('\n'),
+	}
+}
+
+type QueryFunction = (...args: unknown[]) => unknown
+
+function compile(code: string, text: string): QueryFunction {
+	const wrapped = `"use strict"; return (${code}\n);`
+	try {
+		return new Function(
+			'schemas',
+			'Schema',
+			'SchemaInstance',
+			'Table',
+			'Selection',
+			'SingleSelection',
+			'Stream',
+			'Datum',
+			'Query',
+			'ValueProxy',
+			'CROSS_INSTANCE',
+			wrapped,
+		) as QueryFunction
+	} catch (error) {
+		if (!(error instanceof SyntaxError)) throw error
+		// The engine's message points at the wrapper; the editor's parser tells
+		// where the text itself breaks.
+		const place = findSyntaxPlace(text)
+		const where = place ? ` at line ${place.line}, column ${place.column}` : ''
+		throw new QueryInputError(`Syntax error${where}: ${error.message}`, {
+			kind: 'syntax',
+			place,
+			detail: error.message,
+		})
+	}
+}
+
+// `text` is the editor's, so a syntax problem points at its line and column.
+function evaluateUserCode(
+	code: string,
+	text: string,
+	schemas: Record<string, Schema<unknown, SchemaDefLike>>,
+): unknown {
+	return compile(code, text)(
+		guardSchemas(schemas),
+		Schema,
+		SchemaInstance,
+		Table,
+		Selection,
+		SingleSelection,
+		Stream,
+		Datum,
+		Query,
+		ValueProxy,
+		CROSS_INSTANCE,
+	)
+}
+
+// A closing semicolon ends a statement, which the wrapped expression is not.
+const TRAILING_SEMICOLONS = /[;\s]+$/
+
+export function prepareQueryPayload(
+	editorText: string,
+	summaries: SchemaSummary[],
+): PreparedQuery {
+	const trimmed = editorText.trim()
+	if (!trimmed) {
+		throw new Error('Query is empty')
+	}
+
+	const schemas = buildSchemasMap(summaries)
+	const result = evaluateUserCode(
+		trimmed.replace(TRAILING_SEMICOLONS, ''),
+		editorText,
+		schemas,
+	)
+
+	if (!result || typeof result !== 'object') {
+		throw new TypeError(
+			'Query must evaluate to a staged object (e.g. schemas.<id>.instance().table("...").slice(0, 10))',
+		)
+	}
+
+	const stages = (result as { stages?: unknown }).stages
+	if (!Array.isArray(stages)) {
+		throw new TypeError(
+			'Query result is not a staged object — check that the chain ends on a Table/Selection/Stream/Datum/Query.',
+		)
+	}
+
+	const encoded = encodeStaged(result)
+	if (!encoded || typeof encoded !== 'object' || Array.isArray(encoded)) {
+		throw new TypeError('Failed to encode query')
+	}
+
+	return {
+		query: encoded as Record<string, unknown>,
+		source: trimmed,
+		hasMutations: containsMutations(result),
+	}
+}

package/frontend-vue/app/build/composables/useQueryStore.ts

@@ -0,0 +1,162 @@
+export type QueryLanguage = 'aql'
+export type QueryScope = 'me' | 'shared'
+
+export interface SavedQuery {
+	id: string
+	userId: string
+	name: string
+	description: string
+	query: Record<string, unknown>
+	source: string
+	language: QueryLanguage
+	shared: boolean
+	createdAt: string
+	updatedAt: string
+	/** Who saved it, on the team's shared queries. */
+	ownerName?: string
+}
+
+export type QueryRunStatus = 'ok' | 'error'
+
+export interface HistoryEntry {
+	id: string
+	userId: string
+	query: Record<string, unknown>
+	source: string
+	language: QueryLanguage
+	executedAt: string
+	durationMs: number
+	rowCount: number
+	status: QueryRunStatus
+	/** Whether the query wrote. */
+	mutation: boolean
+	error?: string
+}
+
+export interface ExecuteResult {
+	rows: Record<string, unknown>[]
+	/** Rows the query answered; above `rows.length` when they were cut. */
+	rowCount: number
+	truncated: boolean
+	mutation: boolean
+	executedAt: string
+	durationMs: number
+}
+
+export type QueryOperation = 'read' | 'insert' | 'update' | 'replace' | 'delete'
+
+/** What a query would write, measured before it runs. */
+export interface DryRunResult {
+	operation: QueryOperation
+	schema?: string
+	instance?: string
+	table?: string
+	/** Null when the write is nested and cannot be measured on its own. */
+	rows: number | null
+}
+
+export interface SaveQueryInput {
+	name: string
+	description: string
+	query: Record<string, unknown>
+	source: string
+	language: QueryLanguage
+	shared: boolean
+}
+
+import { HISTORY_KEPT } from '../query/runs'
+
+const QUERY_BASE = '/api/database/query'
+
+export function useQueryStore() {
+	const { $authFetch } = useAuthFetch()
+
+	const savedQueries = ref<SavedQuery[]>([])
+	const historyItems = ref<HistoryEntry[]>([])
+
+	async function fetchSaved(scope: QueryScope): Promise<void> {
+		const response = await $authFetch<{ items: SavedQuery[] }>(
+			`${QUERY_BASE}/saved`,
+			{ query: { scope } },
+		)
+		savedQueries.value = response.items ?? []
+	}
+
+	async function fetchHistoryEntry(id: string): Promise<HistoryEntry> {
+		return $authFetch<HistoryEntry>(
+			`${QUERY_BASE}/history/${encodeURIComponent(id)}`,
+		)
+	}
+
+	async function clearHistory(): Promise<void> {
+		await $authFetch<{ success: boolean }>(`${QUERY_BASE}/history`, {
+			method: 'DELETE',
+		})
+		historyItems.value = []
+	}
+
+	async function dryRun(query: Record<string, unknown>): Promise<DryRunResult> {
+		return $authFetch<DryRunResult>(`${QUERY_BASE}/dry-run`, {
+			method: 'POST',
+			body: { query },
+		})
+	}
+
+	/** Every run the server keeps, at once. */
+	async function fetchHistory(): Promise<void> {
+		const response = await $authFetch<{ items: HistoryEntry[] }>(
+			`${QUERY_BASE}/history`,
+			{ query: { limit: HISTORY_KEPT } },
+		)
+		historyItems.value = response.items ?? []
+	}
+
+	async function executeQuery(
+		query: Record<string, unknown>,
+		source: string,
+		language: QueryLanguage,
+	): Promise<ExecuteResult> {
+		return $authFetch<ExecuteResult>(`${QUERY_BASE}/execute`, {
+			method: 'POST',
+			body: { query, source, language },
+		})
+	}
+
+	async function saveQuery(input: SaveQueryInput): Promise<SavedQuery> {
+		return $authFetch<SavedQuery>(`${QUERY_BASE}/saved`, {
+			method: 'POST',
+			body: input,
+		})
+	}
+
+	async function updateSaved(
+		id: string,
+		input: SaveQueryInput,
+	): Promise<SavedQuery> {
+		return $authFetch<SavedQuery>(
+			`${QUERY_BASE}/saved/${encodeURIComponent(id)}`,
+			{ method: 'PUT', body: input },
+		)
+	}
+
+	async function deleteSaved(id: string): Promise<void> {
+		await $authFetch<{ success: boolean }>(
+			`${QUERY_BASE}/saved/${encodeURIComponent(id)}`,
+			{ method: 'DELETE' },
+		)
+	}
+
+	return {
+		savedQueries,
+		historyItems,
+		fetchSaved,
+		fetchHistory,
+		fetchHistoryEntry,
+		clearHistory,
+		dryRun,
+		executeQuery,
+		saveQuery,
+		updateSaved,
+		deleteSaved,
+	}
+}