tabularis-plugin-driver
/tabularis-plugin-driver
Tworzy lub aktualizuje wtyczkę sterownika bazy danych dla Tabularis w Rust: manifest, JSON-RPC przez stdio i układ modułów.
- Autor
- tabularisdb ↗
- Repozytorium
- tabularis ↗
- Licencja
- Apache-2.0
- Ostatnia zmiana repozytorium
- 27.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 3
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
Co robi i kiedy
Tworzy lub aktualizuje wtyczkę sterownika bazy danych dla Tabularis w Rust: manifest, JSON-RPC przez stdio i układ modułów.
Oryginalny opis (EN)
Use when creating or updating a Tabularis database driver plugin in Rust. Covers modern manifest fields, JSON-RPC over stdio, modular plugin layout, MySQL-level feature coverage targets, optional UI extensions, and validation against Tabularis repo rules.
Jak działa
- Goals
- Default Repo Layout
- Required Research Before Coding
- Implementation Workflow
- Testing Strategy
- Validation Checklist
- Tabularis-Specific Rules
- Common Mistakes
- References
Podgląd SKILL.md
---
name: tabularis-plugin-driver
description: "Use when creating or updating a Tabularis database driver plugin in Rust. Covers modern manifest fields, JSON-RPC over stdio, modular plugin layout, MySQL-level feature coverage targets, optional UI extensions, and validation against Tabularis repo rules."
---
# Tabularis Plugin Driver
Use this skill when building or updating a database plugin for Tabularis.
The skill is optimized for this repository. Follow `AGENTS.md`, the files in `.rules/`, and the current plugin-system behavior in `src-tauri/src/plugins/` and `packages/web-ui/src/types/plugins.ts`.
## Goals
- Build a Rust plugin that speaks Tabularis JSON-RPC over stdin/stdout
- Use the modern plugin manifest, not the old minimal format
- Aim for broad feature coverage comparable to the built-in MySQL driver where the target database supports it
- Keep the plugin modular instead of concentrating logic in a single `main.rs`
- Add unit tests for pure utilities and SQL generation
## Default Repo Layout
Prefer this structure for a new plugin repository:
```text
plugin-root/
├── Cargo.toml
├── manifest.json
├── README.md
├── src/
│ ├── main.rs
│ ├── rpc.rs
│ ├── client.rs
│ ├── error.rs
│ ├── models.rs
│ ├── handlers/
│ │ ├── mod.rs
│ │ ├── metadata.rs
│ │ ├── query.rs
│ │ ├── crud.rs
│ │ └── ddl.rs
│ └── utils/
│ ├── mod.rs
│ ├── identifiers.rs
│ ├── values.rs
│ ├── types.rs
│ └── pagination.rs
├── src/bin/
│ └── test_plugin.rs
└── tests/ # only if integration tests are worth the overhead
```
Keep `src/main.rs` thin. It should mostly parse requests, dispatch methods, and serialize responses.
## Required Research Before Coding
1. Read the current plugin manifest shape in:
- `plugins/manifest.schema.json`
- `packages/web-ui/src/types/plugins.ts`
- `src-tauri/src/plugins/manager.rs`
2. Read the JSON-RPC expectations in:
- `plugins/PLUGIN_GUIDE.md`
- `src-tauri/src/plugins/driver.rs`
- `src-tauri/src/plugins/rpc.rs`
3. Read a built-in driver with broad coverage to understand expected behaviors:
- `src-tauri/src/drivers/mysql/mod.rs`
4. Read plugin-loading behavior and modern feature flags in:
- `packages/web-ui/src/hooks/useDrivers.ts`
- `packages/web-ui/src/utils/connectionStringParser.ts`
- `packages/web-ui/src/utils/driverCapabilities.ts`
## Implementation Workflow
### 1. Define plugin scope
Decide which capabilities are truly supported by the target database and driver library:
- `schemas`
- `views`
- `routines`
- `file_based`
- `folder_based`
- `connection_string`
- `connection_string_example`
- `identifier_quote`
- `alter_primary_key`
- `alter_column`
- `create_foreign_keys`
- `manage_tables`
- `readonly`
- `no_connection_required`
Do not advertise support you cannot back with working handlers.
### 2. Create a modern manifest
At minimum define:
- `id`
- `name`
- `version`
- `description`
- `default_port`
- `executable`
- `capabilities`
- `data_types`
- `default_username`
- `color`
- `icon`
Use modern optional fields when useful:
- `settings`
- `ui_extensions`
See [references/manifest-checklist.md](./references/manifest-checklist.md).
### 3. Build a modular RPC surface
Implement the request loop in `main.rs`, but move logic out immediately:
- `rpc.rs`: request parsing, success/error helpers, method routing support
- `client.rs`: connection config, client creation, pooling or reuse key logic
- `handlers/metadata.rs`: databases, schemas, tables, columns, indexes, foreign keys, views, routines
- `handlers/query.rs`: `test_connection`, `ping`, `execute_query`, `count_query`, `explain_query_plan` if possible
- `handlers/crud.rs`: `insert_record`, `update_record`, `delete_record`
- `handlers/ddl.rs`: SQL generation helpers and DDL RPC methods
- `utils/*`: quoting, escaping, value formatting, type normalization, pagination math
### 4. Target broad feature coverage
Use the built-in MySQL driver as the feature benchmark, not as text to copy.
For each feature area, classify it:
- `supported`: implement fully
- `partially_supported`: implement with explicit limitations
- `unsupported`: return an accurate error or empty result as appropriate
Prioritize these methods:
- `test_connection`
- `get_databases`
- `get_schemas`
- `get_tables`
- `get_columns`
- `get_foreign_keys`
- `get_indexes`
- `get_views`
- `get_view_definition`
- `get_view_columns`
- `get_routines`
- `get_routine_parameters`
- `get_routine_definition`
- `execute_query`
- `insert_record`
- `update_record`
- `delete_record`
- `get_schema_snapshot`
- `get_all_columns_batch`
- `get_all_foreign_keys_batch`
- `get_create_table_sql`
- `get_add_column_sql`
- `get_alter_column_sql`
- `get_create_index_sql`
- `get_create_foreign_key_sql`
- `drop_index`
- `drop_foreign_key`
If a method is not safe to emulate, fail explicitly instead of faking success.
#### Optional routine-management methods
When the manifest declares `"routine_management": true`, the host shows
run / create / edit / drop actions for routines. The backing RPC methods are
**optional**: if the plugin does not implement one, the host answers the
JSON-RPC "method not found" error (-32601) with a dialect-neutral fallback
(`CALL name(args)` / `SELECT name(args)`, generic `DROP`, the raw definition
as edit script). Implement only what the dialect needs:
- `build_routine_call_sql({ params, routine_name, routine_type, args, schema }) -> string` —
`args` is an ordered list of `{ name, mode, value: string|null, is_raw: bool }`;
return an executable invocation script (it is opened in the editor, so
multi-statement scripts are fine — e.g. MySQL's `SET @out` / `CALL` / `SELECT @out`).
- `routine_create_template({ routine_type, schema }) -> string` — starter
script for a new PROCEDURE/FUNCTION in the plugin's dialect.
- `get_routine_edit_script({ params, routine_name, routine_type, schema }) -> string` —
re-runnable script to alter the routine (e.g. `DROP` + `CREATE`, or
`CREATE OR REPLACE`).
- `drop_routine({ params, routine_name, routine_type, schema }) -> null` —
drop the routine; resolve overloads yourself if the dialect has them.
### 5. Add settings only when they solve a real problem
Typical useful settings:
- DSN name
- driver/library path
- default schema
- TLS mode
- extra connection properties
Keep settings in the manifest and resolve them in a dedicated config path, not inline in handlers.
### 6. Add UI extensions only when the database needs them
Examples of good reasons:
- a custom connection helper for DSN-based setup
- an advanced settings panel for database-specific options
- contextual UI for unsupported-but-important caveats
Avoid UI extensions that only decorate the product without improving DB-specific workflows.
## Testing Strategy
Always add unit tests for pure logic:
- identifier quoting
- SQL builders
- type normalization
- pagination helpers
- value serialization
- capability-driven helper decisions
Prefer pure utility modules so tests stay fast and deterministic.
If the plugin includes a JSON-RPC smoke binary like `src/bin/test_plugin.rs`, use it to simulate Tabularis requests over stdio.
## Validation Checklist
Before finishing:
- `cargo test`
- `cargo build --release`
- smoke test at least one JSON-RPC request through stdin/stdout
- verify `manifest.json` matches current Tabularis schema and capabilities
- verify any advertised capability has corresponding handler behavior
- verify unsupported operations return clear errors
## Tabularis-Specific Rules
- Comments and docs must be in English
- Keep code split by responsibility; avoid a monolithic `main.rs`
- Add unit tests for extracted utility logic
- When updating this repo itself, follow `AGENTS.md` requirements including GitNexus impact analysis before editing existing symbols
- Use `pnpm` for frontend-side validation in this repo and `cargo` for plugin validation
## Common Mistakes
- copying old plugin manifests that omit modern fields
- putting connection logic, SQL generation, RPC parsing, and metadata extraction in one file
- advertising `manage_tables` or `alter_column` without implementing the related methods
- returning fake empty success for operations that should surface unsupported behavior
- skipping tests for identifier quoting and SQL generation
## References
- Manifest details: [references/manifest-checklist.md](./references/manifest-checklist.md)
Pliki w paczce (3)
- SKILL.md 8 KB
- agents/openai.yaml 1 KB
- references/manifest-checklist.md 3 KB
Wersje
W bazie nie ma innych skilli o nazwie tabularis-plugin-driver.
Migawka bazy z 13.11.2026 · wersja paczki 5b7f868e8a45 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100tabularis-pr-review
Przegląda lokalnie pull request Tabularis: jakość kodu według reguł repozytorium, testy na właściwej gałęzi i plan testów ręcznych z danymi. - 100tabularis-run-macos
Uruchamia aplikację Tabularis na macOS i steruje nią przez tauri-wd: klika, wypełnia formularze, robi zrzuty okna i sprawdza wynik na dysku. - 100plugin-author
Pomaga napisać wtyczkę Shipyard z plikiem manifest.json i katalogiem files oraz ją spakować. - 100package-author
Pakuje narzędzie w standardowy pakiet pinvou: dopisuje plugin.json, manifest MCP, SKILL.md i ikonę oraz sprawdza poprawność nazw. - 100plugin-structure
Pomaga zaplanować strukturę wtyczki Claude Code: plugin.json, katalogi komponentów, hooki i zmienne ścieżek. - 100bump-version
Synchronicznie podnosi wersję pakietu i pluginu: aktualizuje package.json, .claude-plugin/plugin.json i manifest install-state do tej samej wersji.