JauntyQ Roadmap
Living list of post-baseline work. Items are grouped by whether they are being built now, planned next, or deferred. Non-goals are recorded so scope stays honest.
In progress / next
(nothing currently in progress)
Planned (spec-first)
The differentiator ("moat") specs authored 2026-07-10 (007–012) have all been
built and merged to dev (2026-07-11), see Shipped below. Nothing else is
currently queued.
Under evaluation (built, ship/hold decision pending):
- License enforcement. Signed offline
jaunty.license.json,jauntyq activateand entitlement gating are built and live inExtrode.JauntyQ.Cli.Premium:schema verify,migrate impact,explain,registryandusage exportconsult the gate. The core codegen is never gated, and a lapse only warns, never hard-fails. What remains is commercial rather than technical. Seedocs/03-guides/licensing-and-activation.md.
Dropped (for SQL Server):
- Bespoke Visual Studio extension for SQL Server. Visual Studio ships native SQL Server support (SQL Server Object Explorer, T-SQL IntelliSense, live database validation) out of the box. Building a JauntyQ-specific extension would duplicate that for the one dialect VS already covers well. Not worth building.
Under consideration (future, not now — no commitment):
Bespoke Visual Studio extension for PostgreSQL, MySQL/MariaDB, and SQLite. Unlike SQL Server, Visual Studio has no built-in editing or live validation for these three dialects; support today comes only from third-party extensions of uneven quality, maintenance, and pricing. A JauntyQ-authored extension giving these dialects the same
.sqlediting + live-validation experience SQL Server users get natively is a real gap and may be worth building later. No commitment, no timeline.Scoping (2026-09-19, training-knowledge based, not a live web search — verify before spec'ing):
- Reusable infra:
Extrode.JauntyQ.SqlParser+Extrode.JauntyQ.Analysisare already offline, Roslyn-free, dialect-aware SQL tokenizer/parser/ validator libraries used today for build-time diagnostics. They lower the floor for autocomplete/inline-validation logic; the missing pieces are editor integration and live schema introspection, not SQL understanding. - Landscape (VS-native, not VS Code — different extensibility model): no maintained free/OSS VS extension reaches SQL Server-level parity for any of the three dialects. Postgres and MySQL/MariaDB have only aging or commercial options (e.g. Oracle's "MySQL for Visual Studio", dbForge); SQLite has more actively maintained community tooling (e.g. SQLite/SQL Server Compact Toolbox) but scoped to data browsing, not schema-aware IntelliSense. Full IDEs (DBeaver, DataGrip, Azure Data Studio) cover all three well but are separate products, not VS extensions.
- Architecture: VS's newer LSP client support
(
Microsoft.VisualStudio.LanguageServer.Client) is the leverage point — one shared LSP host + a pluggable per-dialect backend (reusingSqlParser's existing dialect modes), rather than three independent heavyweight VSPackage/MEF extensions. Live schema introspection still needs each dialect's own ADO provider (Npgsql, MySqlConnector, Microsoft.Data.Sqlite) wired in separately — that part doesn't share. - Effort: one dialect to IntelliSense + inline-validation parity (not full Server Explorer/execution-plan parity) is roughly 2-4 months for one experienced developer. All three, built LSP-first with a shared host, is closer to 1.6-2x a single dialect's effort rather than 3x — still a multi-quarter effort, not a side project. Full parity with SQL Server's native depth (Server Explorer-grade connection browsing, execution plan visualization, project-wide rename refactoring) is a dedicated-team, multi-quarter undertaking on top of that.
- Hardest parity gaps: (1) live graphical execution-plan visualization —
no VS-native equivalent to render Postgres/MySQL
EXPLAINoutput against, though the existingjauntyq explainCLI's cached EXPLAIN output could seed this; (2) Server Explorer-grade live connection/object-tree browsing; (3) rename-across-references refactoring, which needs project-wide reference tracking beyond editor-level IntelliSense. - Recommendation: not yet — needs more research. The reusable parser lowers the floor but this still competes with existing commercial tooling and unvalidated demand (how many JauntyQ prospects use non-SQL-Server dialects in Visual Studio specifically, vs. VS Code or Rider). Before spec'ing: a live web search to confirm/refresh the landscape survey above, and a demand check with prospects/customers.
Live research (2026-10-01): don't build now, revisit around 2027-04.
- Gap confirmed: no VS extension gives schema-aware
.sqlIntelliSense or live validation for any of the three dialects. Oracle's MySQL for Visual Studio has been in Sustaining Support since 2022-12-08, and both Microsoft and Oracle now point users to VS Code. Microsoft's PostgreSQL extension (IntelliSense, Object Explorer, query plans) is VS Code only. - Scoping corrections:
- The free Npgsql PostgreSQL Integration extension exists but covers only Server Explorer and EF6.
- SQLite Toolbox also scripts, imports and exports, and supports VS 2026, but has no IntelliSense.
Microsoft.Build.Sql(SDK-style SQL projects) is SQL Server only and not supported in VS 2026.- The 2-4 month estimate is unverified.
- Platform: VisualStudio.Extensibility's out-of-process
LanguageServerProvideris documented. Out-of-process extensions are reported to lack Error List and tagger parity, which a live-validation product needs. That report is unverified as fixed. - Demand: unproven. A 2026-05 Visual Studio Magazine poll on more DB tooling in VS split 44% for and 41% against (34 votes). No Developer Community request for Postgres or MySQL IntelliSense in VS was found. Rider (bundled DataGrip) and VS Code cover these dialects well and for free. JauntyQ's generator already validates at build time in VS, so an extension would add editor-time polish, not coverage.
- Revisit when a Developer Community request for these dialects gains traction, Microsoft closes the out-of-process Error List gap, or JauntyQ users ask for it.
- Reusable infra:
Shipped
- Migration Impact Analysis (003). Reuses the migration simulator + query
validator to report which queries a pending migration set affects, classified
SAFE / RISKY / BREAKING, at build time (
JNT9004RISKY warning) and via the offlinejauntyq migrate impactCLI verb. The shared Roslyn-free engine now lives inExtrode.JauntyQ.Analysis.. - Deeper query analysis (004). Added
JNT8006(join-not-a-foreign-key) andJNT8007(ORDER BY without a supporting index) to the offline JNT8xxx perf pass, plus ORDER BY capture in the SqlParser IR. The N+1 heuristic from the original scope was split out as 008, which has since shipped too (see below).. - Database contract testing (005). The structural CI-gate core shipped: the
Extrode.JauntyQ.Schema.ContractNuGet (test-embeddable assertion API + a fixed breaking/compatible severity model) and an upgradedjauntyq schema verify(--format,--fail-on); the extractors were relocated out of the CLI so the core stays zero-dependency. The per-service contracts and central registry parts of the original vision were split into Planned specs 010 + 009 (and runtime startup verification + usage-aware severity into 011 + 012).. - N+1 query heuristic (008). Build-time, offline
JNT8008(Warning) over the query corpus + FK graph: pairs a child point-lookup by foreign key with a parent-collection query and suggests a join or batchedIN, with guards (already-IN, joined child, single-row-PK parent, no FK, project-level suppression). The perf check split out of 004.. - Opt-in live EXPLAIN plan analyzer (007).
jauntyq explainCLI verb only, so the Roslyn generator stays offline; lives in the non-coreExtrode.JauntyQ.Explainlibrary. Per-dialect estimate-onlyEXPLAIN(Postgres/SQLite/MySQL/SQL Server), capped, cached at.jaunty/explain-cache.json, report-only (exit 0; opt-in--fail-on), a missing/unreachable DB skips cleanly. Entitlement-gated.. - Central schema-dependency registry (009).
jaunty.registry.jsonnaming schema snapshots + the services that depend on them, withregistry resolve|dependents|validate|list, in the non-coreExtrode.JauntyQ.Registrylibrary. Additive/opt-in; the substrate for per-service contracts.. - Per-service contracts (010). Registry-driven scope filter for
schema verify(--service/--registry) that narrows a contract to the slice a service actually depends on (narrows, never widens), so another service's change does not fail this service's gate. Builds on 005 + 009.. - Runtime startup verification (011). Opt-in boot-time
StartupSchemaGuard(fail-fast / warn / skip per policy) in the non-coreExtrode.JauntyQ.Schema.Contractpackage, with optional<JauntyQEmbedSnapshot>build wiring;Extrode.JauntyQ.Runtimestays zero-dependency.. - Usage-aware severity (012). Opt-in, downgrade-only
UsageAwareReclassifierjauntyq usage export(usage manifest fromReferencedObjects);schema verify --usagedowngrades breaking drift on objects no generated query references and never hides a real break. Composes with 010 scope..
- DDL-as-schema-source (sqlc-style). A project with no pulled JSON snapshot
can define its base schema purely from
CREATE TABLE/ALTER TABLEfiles under thedb/ddl/*.sqlconvention, reusing the existing migration parser + schema simulator to build the schema from an empty database. Framed as an alternative input, not a replacement: when a.schema.jsonsnapshot is present it stays authoritative and anydb/ddl/*.sqlfiles are silently ignored (no merge, no error). Because there is no snapshot to infer the dialect from, DDL mode requires the consumer to declare it in the.csprojvia<JauntyQDialect>sqlserver</JauntyQDialect>(orpostgres,mysql,sqlite); a missing/unrecognized value is a build error (JNT9003). Existingdb/migrations/*.sqlfiles still apply on top of the ddl-built base exactly as they apply on top of a snapshot. Known limitation: the migration parser does not model index DDL, so tables defined in DDL/migration files expose PK/identity/column-type info but no secondary unique indexes, the JNT8004 composite-index check and Upsert alternate-key resolution only ever see the PK for such tables. (Indexes, procedures, and sequences captured in a pulled snapshot survive migration simulation unchanged.) - Provider-native bulk fast paths.
BulkInsert(IEnumerable<Row>)/BulkInsertAsync(and their static overloads) now specialize the emission per dialect: Npgsql binaryCOPY(Postgres),SqlBulkCopy(SQL Server), andMySqlBulkCopy(MySQL). SQL Server and MySQL feed theirWriteToServerthrough a single reflection-free, AOT-safeDbDataReader-over-IEnumerable<Row>adapter emitted once per table (ordinal-basedswitch, no reflection).sqliteand any unrecognized dialect keep the portable single-transaction prepared-command loop unchanged. Note: theMySqlBulkCopypath requires the consumer's connection string to setAllowLoadLocalInfile=true(and the server to allowLOCAL INFILE); JauntyQ cannot set this and documents it on the generated method. - Sequences (SQL Server + PostgreSQL + MariaDB).
jauntyq schema pullcaptures sequence objects and the generator emits typeddb.Sequences.Next{Name}()/Next{Name}Async()accessors. Real/Oracle MySQL and SQLite have no true sequence object, so this is dialect-specific; MariaDB (which shares themysqldialect string with real MySQL) is detected separately and does get accessors, usingSELECT NEXTVAL(<seq>). (Broader schema-object generation, functions, enums, UDTs, remains deferred; see below.) - API reference / JNT diagnostics reference docs.
docs/06-reference/diagnostics.md(every JNTxxxx code, severity, meaning) anddocs/06-reference/api-overview.md(shape of the generated surface, pointing to XML doc comments insrc/Extrode.JauntyQ.Generator/CodeEmitter*.csas the authoritative reference), alongside the CLI, configuration, snapshot-format, directives, and dialect references underdocs/06-reference/. Full XML-doc-driven site generation (DocFX or similar) remains deferred; see below. - SBOM generation.
.github/workflows/release.ymlgenerates a CycloneDX SBOM (dotnet CycloneDX) for every tagged release and attaches it alongside the packages, no signing cert needed for this part. - Parser hardening (report M3). Unterminated-token diagnostics (JNT1002)
and input-size caps (JNT1003,
SqlTokenizer.MaxInputLength).
Deferred (future, not now)
Broader schema-object generation. Functions, enums, and UDTs (jOOQ-level completeness). Sequences already shipped (see above); this covers the remaining object types. Lower priority.
Package signing. The core packages ship from NuGet.org over HTTPS with repository signing by the feed. Authenticode or NuGet author signing is a value-add warranted when an enterprise customer's policy demands it or when a native-AOT CLI binary ships; it would go through a cloud signer, never a stored
.pfx.XML-doc-driven API reference site (DocFX or similar). A generated site built from the generator's XML doc comments; the hand-written
docs/06-reference/pages cover the reference need for now.Scoped (2026-09-19): JauntyQ's docs already run on a shared engine — the sibling repo
../docs(github.com/extrode/docs, néeBeparey.DocsGen), whichscripts/build-docs.shinvokes directly (../docs/src/Docs). That engine is a pure markdown-in/HTML-out static-site pipeline (Markdig + System.CommandLine only — no Roslyn, no reflection): it walks a numbered markdown tree and renders theming, sidebar nav, per-page TOC, search index, and Mermaid-to-SVG at build time. It has no XML-doc-comment or reflection-based API reference capability today — confirmed by grepping its entire source tree forXmlDoc/DocFX/Reflection/Roslynwith zero hits. So adopting a site generator is already done; generating reference pages from XML doc comments is not, and is a genuinely new component, not a config flag on the existing engine. Smallest-lift design: a converter that reads the generator's.xmldoc-comment file + reflects over its public members (resolving<see cref>/<paramref>etc.) and emits pages into the same numbered-markdown-tree shape../docsalready consumes — reuses theming, nav, search, and versioning for free, and confines the new work to member enumeration + doc-comment parsing + a markdown template per member kind. Roughly comparable in scope to a small DocFX subset. Still deferred; no timeline.
Non-goals (owned elsewhere or out of scope)
- Dynamic / runtime-composed SQL, this is Jaunty's job, not JauntyQ's. JauntyQ keeps the "all SQL known and validated at build time" contract.
- LINQ query composition, change tracking, lazy loading, entity graphs, EF Core's domain; deliberately rejected ("SQL as source of truth").