@adecore/database 0.0.1 → 0.16.0-beta.0

package/dist/workbench/TableTab.d.ts

@@ -0,0 +1,10 @@
+import type { Connection } from '../client/types.ts';
+import type { WorkbenchTab } from './tabs.ts';
+export interface TableTabProps {
+    connection: Connection;
+    tab: Extract<WorkbenchTab, {
+        kind: 'table';
+    }>;
+    onDirtyChange?(dirty: boolean): void;
+}
+export declare function TableTab({ connection, tab, onDirtyChange }: TableTabProps): import("react").JSX.Element;

package/dist/workbench/TableTab.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { StructureView } from '../structure/StructureView.js';
+import { TableView } from '../table/TableView.js';
+/* The data and the structure of one table, the one that `tab.view` names in front. Both stay mounted, so pending edits in the data survive a look at the structure. */
+export function TableTab({ connection, tab, onDirtyChange }) {
+    const { schema, table } = tab.ref;
+    return (_jsxs("div", { className: "flex h-full min-h-0 flex-col", children: [_jsx("div", { className: "min-h-0 flex-1", hidden: tab.view !== 'data', children: _jsx(TableView, { connection: connection, schema: schema, table: table, defaultWhere: tab.where, onDirtyChange: onDirtyChange, className: "h-full" }) }), _jsx("div", { className: "min-h-0 flex-1", hidden: tab.view !== 'structure', children: _jsx(StructureView, { connection: connection, schema: schema, table: table, className: "h-full" }) })] }));
+}

package/dist/workbench/tabs.d.ts

@@ -0,0 +1,42 @@
+import type { TableRef } from '../client/types.ts';
+export type TableViewMode = 'data' | 'structure';
+export type WorkbenchTab = {
+    readonly id: string;
+    readonly kind: 'table';
+    readonly ref: TableRef;
+    readonly view: TableViewMode;
+    readonly where?: string;
+} | {
+    readonly id: string;
+    readonly kind: 'console';
+    readonly connectionId: string;
+    readonly schema?: string;
+    readonly sql: string;
+    readonly number: number;
+} | {
+    readonly id: string;
+    readonly kind: 'designer';
+    readonly connectionId: string;
+    readonly schema: string;
+    readonly table?: string;
+};
+export interface WorkbenchState {
+    readonly tabs: readonly WorkbenchTab[];
+    readonly activeId: string | null;
+    readonly serial: number;
+    readonly consoles: number;
+}
+export declare const STORAGE_KEY = "database:workbench";
+export declare const emptyState: WorkbenchState;
+export declare const connectionIdOf: (tab: WorkbenchTab) => string;
+export declare const focusTab: (state: WorkbenchState, id: string) => WorkbenchState;
+export declare const openTable: (state: WorkbenchState, ref: TableRef, view: TableViewMode, where?: string) => WorkbenchState;
+export declare const openConsole: (state: WorkbenchState, connectionId: string, schema?: string, sql?: string) => WorkbenchState;
+export declare const openDesigner: (state: WorkbenchState, connectionId: string, schema: string, table?: string) => WorkbenchState;
+export declare const setTableView: (state: WorkbenchState, id: string, view: TableViewMode) => WorkbenchState;
+export declare const setConsoleSql: (state: WorkbenchState, id: string, sql: string) => WorkbenchState;
+export declare const setDesignerTable: (state: WorkbenchState, id: string, table: string) => WorkbenchState;
+export declare const closeTab: (state: WorkbenchState, id: string) => WorkbenchState;
+export declare const pruneTabs: (state: WorkbenchState, connectionIds: ReadonlySet<string>) => WorkbenchState;
+export declare const serializeState: (state: WorkbenchState) => string;
+export declare const parseState: (raw: string | null) => WorkbenchState;

package/dist/workbench/tabs.js

@@ -0,0 +1,139 @@
+export const STORAGE_KEY = 'database:workbench';
+export const emptyState = { tabs: [], activeId: null, serial: 0, consoles: 0 };
+export const connectionIdOf = (tab) => (tab.kind === 'table' ? tab.ref.connectionId : tab.connectionId);
+const tableTabId = (ref) => `table:${ref.connectionId}\u0000${ref.schema}\u0000${ref.table}`;
+const add = (state, tab) => ({ ...state, tabs: [...state.tabs, tab], activeId: tab.id });
+const update = (state, id, change) => {
+    let changed = false;
+    const tabs = state.tabs.map((tab) => {
+        if (tab.id !== id) {
+            return tab;
+        }
+        const next = change(tab);
+        changed ||= next !== tab;
+        return next;
+    });
+    return changed ? { ...state, tabs } : state;
+};
+export const focusTab = (state, id) => state.activeId === id || !state.tabs.some((tab) => tab.id === id) ? state : { ...state, activeId: id };
+/* A table opens once per table; a filtered one is always a tab of its own, since the filter is what the person asked to see. */
+export const openTable = (state, ref, view, where) => {
+    if (where !== undefined && where.trim() !== '') {
+        return add({ ...state, serial: state.serial + 1 }, { id: `filtered:${state.serial + 1}`, kind: 'table', ref, view, where });
+    }
+    const id = tableTabId(ref);
+    const existing = state.tabs.find((tab) => tab.id === id);
+    if (existing === undefined) {
+        return add(state, { id, kind: 'table', ref, view });
+    }
+    return focusTab(setTableView(state, id, view), id);
+};
+export const openConsole = (state, connectionId, schema, sql = '') => {
+    const serial = state.serial + 1;
+    const consoles = state.consoles + 1;
+    return add({ ...state, serial, consoles }, { id: `console:${serial}`, kind: 'console', connectionId, schema, sql, number: consoles });
+};
+/* A table is designed in one tab; a new table gets a tab each time. */
+export const openDesigner = (state, connectionId, schema, table) => {
+    const existing = table === undefined
+        ? undefined
+        : state.tabs.find((tab) => tab.kind === 'designer' && tab.connectionId === connectionId && tab.schema === schema && tab.table === table);
+    if (existing !== undefined) {
+        return focusTab(state, existing.id);
+    }
+    const serial = state.serial + 1;
+    return add({ ...state, serial }, { id: `designer:${serial}`, kind: 'designer', connectionId, schema, table });
+};
+export const setTableView = (state, id, view) => update(state, id, (tab) => (tab.kind === 'table' && tab.view !== view ? { ...tab, view } : tab));
+export const setConsoleSql = (state, id, sql) => update(state, id, (tab) => (tab.kind === 'console' && tab.sql !== sql ? { ...tab, sql } : tab));
+/* The designer of a new table became the designer of that table, in the same tab. Closes any other designer of it. */
+export const setDesignerTable = (state, id, table) => {
+    const subject = state.tabs.find((tab) => tab.id === id);
+    if (subject?.kind !== 'designer' || subject.table === table) {
+        return state;
+    }
+    const tabs = state.tabs.filter((tab) => tab.id === id || !(tab.kind === 'designer' && tab.connectionId === subject.connectionId && tab.schema === subject.schema && tab.table === table));
+    return update({ ...state, tabs }, id, (tab) => (tab.kind === 'designer' ? { ...tab, table } : tab));
+};
+/* The tab next to the closed one comes forward when the closed one was in front. */
+export const closeTab = (state, id) => {
+    const at = state.tabs.findIndex((tab) => tab.id === id);
+    if (at < 0) {
+        return state;
+    }
+    const tabs = state.tabs.filter((tab) => tab.id !== id);
+    return { ...state, tabs, activeId: state.activeId === id ? (tabs[Math.min(at, tabs.length - 1)]?.id ?? null) : state.activeId };
+};
+/* Drops the tabs of connections that are gone. */
+export const pruneTabs = (state, connectionIds) => {
+    const tabs = state.tabs.filter((tab) => connectionIds.has(connectionIdOf(tab)));
+    if (tabs.length === state.tabs.length) {
+        return state;
+    }
+    return { ...state, tabs, activeId: tabs.some((tab) => tab.id === state.activeId) ? state.activeId : (tabs.at(-1)?.id ?? null) };
+};
+export const serializeState = (state) => JSON.stringify({ version: 1, ...state });
+const isText = (value) => typeof value === 'string' && value !== '';
+const isOptionalText = (value) => value === undefined || typeof value === 'string';
+const refOf = (value) => {
+    const ref = value;
+    return typeof ref === 'object' && ref !== null && isText(ref.connectionId) && isText(ref.schema) && isText(ref.table)
+        ? { connectionId: ref.connectionId, schema: ref.schema, table: ref.table }
+        : null;
+};
+const tabOf = (value) => {
+    const raw = value;
+    if (typeof raw !== 'object' || raw === null || !isText(raw.id)) {
+        return null;
+    }
+    const id = raw.id;
+    switch (raw.kind) {
+        case 'table': {
+            const ref = refOf(raw.ref);
+            const view = raw.view === 'structure' ? 'structure' : 'data';
+            return ref === null || !isOptionalText(raw.where) ? null : { id, kind: 'table', ref, view, where: raw.where };
+        }
+        case 'console':
+            return isText(raw.connectionId) && isOptionalText(raw.schema) && typeof raw.sql === 'string' && typeof raw.number === 'number'
+                ? { id, kind: 'console', connectionId: raw.connectionId, schema: raw.schema, sql: raw.sql, number: raw.number }
+                : null;
+        case 'designer':
+            return isText(raw.connectionId) && isText(raw.schema) && isOptionalText(raw.table)
+                ? { id, kind: 'designer', connectionId: raw.connectionId, schema: raw.schema, table: raw.table }
+                : null;
+        default:
+            return null;
+    }
+};
+/* What a past run stored, or an empty workbench for anything that is missing or not ours. A tab that is not valid is left out, the rest stays. */
+export const parseState = (raw) => {
+    if (raw === null) {
+        return emptyState;
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return emptyState;
+    }
+    if (typeof data !== 'object' || data === null || data.version !== 1 || !Array.isArray(data.tabs)) {
+        return emptyState;
+    }
+    const seen = new Set();
+    const tabs = data.tabs.map(tabOf).filter((tab) => {
+        if (tab === null || seen.has(tab.id)) {
+            return false;
+        }
+        seen.add(tab.id);
+        return true;
+    });
+    const activeId = typeof data.activeId === 'string' && seen.has(data.activeId) ? data.activeId : (tabs.at(-1)?.id ?? null);
+    const counter = (value) => (typeof value === 'number' && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 0);
+    return {
+        tabs,
+        activeId,
+        serial: Math.max(counter(data.serial), ...tabs.map((tab) => Number(/^(?:filtered|console|designer):(\d+)$/.exec(tab.id)?.[1] ?? 0))),
+        consoles: Math.max(counter(data.consoles), ...tabs.map((tab) => (tab.kind === 'console' ? tab.number : 0)))
+    };
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adecore/database",
-  "version": "0.0.1",
-  "description": "Placeholder that reserves the name for trusted publishing. The first real version follows from the release workflow.",
+  "version": "0.16.0-beta.0",
+  "description": "Browse, query and edit SQLite and MySQL databases: React views for the page, a host for the backend and a native helper that talks to the server.",
   "license": "MIT",
   "author": "Bas Milius",
   "repository": {
@@ -9,6 +9,82 @@
     "url": "git+https://github.com/basmilius/adecore.git",
     "directory": "packages/database"
   },
+  "bugs": {
+    "url": "https://github.com/basmilius/adecore/issues"
+  },
   "homepage": "https://adecore.dev/database/",
-  "files": ["README.md"]
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/__snapshots__",
+    "!src/testing/stub.ts",
+    "!src/testing/dom"
+  ],
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./protocol": {
+      "source": "./src/protocol/index.ts",
+      "types": "./dist/protocol/index.d.ts",
+      "default": "./dist/protocol/index.js"
+    },
+    "./host": {
+      "source": "./src/host/index.ts",
+      "types": "./dist/host/index.d.ts",
+      "default": "./dist/host/index.js"
+    },
+    "./testing": {
+      "source": "./src/testing/index.ts",
+      "types": "./dist/testing/index.d.ts",
+      "default": "./dist/testing/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun scripts/build.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "test:dom": "bun test --preload ./src/testing/dom/preload.ts interaction",
+    "helper:build": "cargo build --release --locked --manifest-path helper/Cargo.toml",
+    "helper:check": "cargo fmt --manifest-path helper/Cargo.toml --check && cargo clippy --locked --manifest-path helper/Cargo.toml --all-targets -- -D warnings",
+    "helper:test": "cargo test --locked --manifest-path helper/Cargo.toml"
+  },
+  "dependencies": {
+    "@base-ui-components/react": "^1.0.0-rc.0",
+    "clsx": "^2.1.1",
+    "lucide-react": "^1.47.0"
+  },
+  "optionalDependencies": {
+    "@adecore/database-darwin-arm64": "0.16.0-beta.0",
+    "@adecore/database-linux-arm64": "0.16.0-beta.0",
+    "@adecore/database-linux-x64": "0.16.0-beta.0",
+    "@adecore/database-win32-x64": "0.16.0-beta.0"
+  },
+  "peerDependencies": {
+    "@adecore/ui": "^0.16.0-beta.0",
+    "i18next": "^26.4.2",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "react-i18next": "^17.0.15"
+  },
+  "devDependencies": {
+    "@adecore/ui": "workspace:*",
+    "@happy-dom/global-registrator": "^20.14.5",
+    "@types/bun": "^1.4.2",
+    "@types/node": "^24.13.6",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "i18next": "^26.4.2",
+    "oxc-parser": "^0.151.0",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "react-i18next": "^17.0.15",
+    "typescript": "^7.0.2"
+  }
 }

package/src/DatabaseProvider.tsx

@@ -0,0 +1,37 @@
+import { useMemo, useState, type ReactNode } from 'react';
+import { useTranslation } from 'react-i18next';
+import type { DatabaseAction, DatabaseFiles, DatabaseStorage } from './actions.ts';
+import type { DatabaseClient } from './client/types.ts';
+import { DatabaseContext } from './client-context.ts';
+import type { NumberNotation } from './grid/display.ts';
+import { addDatabaseResources } from './locales.ts';
+
+export interface DatabaseProviderProps {
+    client: DatabaseClient;
+    /* Where a table, a console or the designer a view asks for opens. Without it the views offer none of those. */
+    onAction?(action: DatabaseAction): void;
+    storage?: DatabaseStorage;
+    files?: DatabaseFiles;
+    /*
+     * How cells show integers, decimals and floats. `'database'` draws them as the server wrote them, which is what a
+     * database tool is read for; `'region'` draws them in the number format of `@adecore/ui`'s format source.
+     * Editing, copying, filters, export and everything sent to the server keep the server's text either way.
+     */
+    numberNotation?: NumberNotation;
+    children: ReactNode;
+}
+
+/* Hands every view below it the client and the app's hooks, and adds the package's words to the i18next the app's `UIProvider` was given. Mount it inside that provider. */
+export function DatabaseProvider({ client, onAction, storage, files, numberNotation = 'database', children }: DatabaseProviderProps) {
+    const { i18n } = useTranslation();
+    const [added, setAdded] = useState<typeof i18n | null>(null);
+    // In render, as `UIProvider` does, so the first view already reads its words.
+    if (added !== i18n) {
+        addDatabaseResources(i18n);
+        setAdded(i18n);
+    }
+
+    const value = useMemo(() => ({ client, onAction, storage, files, numberNotation }), [client, onAction, storage, files, numberNotation]);
+
+    return <DatabaseContext value={value}>{children}</DatabaseContext>;
+}

package/src/actions.ts

@@ -0,0 +1,34 @@
+import type { TableRef } from './client/types.ts';
+
+/*
+ * Something a view asks the app to open. The views draw no tabs and no windows of their own: the app
+ * decides where a table, a console or the designer lands, such as a tab beside its file tabs.
+ */
+export type DatabaseAction =
+    /* `where` opens the table filtered, as a jump along a foreign key does. */
+    | { readonly kind: 'open-table'; readonly ref: TableRef; readonly view: 'data' | 'structure'; readonly where?: string }
+    | { readonly kind: 'open-console'; readonly connectionId: string; readonly schema?: string; readonly sql?: string }
+    | { readonly kind: 'new-table'; readonly connectionId: string; readonly schema: string }
+    | { readonly kind: 'edit-table'; readonly ref: TableRef }
+    /* The app opens its connection manager on this connection. */
+    | { readonly kind: 'manage-connection'; readonly connectionId: string };
+
+/* What is selected in the explorer: a connection, a schema in it, or a table in that schema. */
+export interface ExplorerSelection {
+    readonly connectionId: string;
+    readonly schema?: string;
+    readonly table?: string;
+}
+
+/* Where the views keep what a person set (console history, column widths, filters) across a remount. Synchronous, like `localStorage`. */
+export interface DatabaseStorage {
+    get(key: string): string | null;
+    /* `null` removes the key. */
+    set(key: string, value: string | null): void;
+}
+
+/* The app's file dialogs, for export and import. Each resolves the chosen absolute path, or `null` when the person cancelled. */
+export interface DatabaseFiles {
+    save(options: { readonly suggestedName: string; readonly format: 'csv' | 'tsv' | 'json' | 'sql' }): Promise<string | null>;
+    open(options: { readonly formats: readonly ('csv' | 'tsv')[] }): Promise<string | null>;
+}