Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

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.

Repozytorium
tabularis ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
3
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

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

  1. Goals
  2. Default Repo Layout
  3. Required Research Before Coding
  4. Implementation Workflow
  5. Testing Strategy
  6. Validation Checklist
  7. Tabularis-Specific Rules
  8. Common Mistakes
  9. References
Sekcje z nagłówków SKILL.md, w oryginale · 255 linii, 1 079 słów
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.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.