Ignyte.Inquiry.Testing 1.0.0-preview.10

Inquiry

Inquiry is an experimental .NET 8+ source-generated micro-ORM. You write attributed entity classes and partial store classes with partial method declarations; a Roslyn source generator emits the matching partial with method bodies, materializers, and dependency-injection wiring. Every SQL string is built at compile time by a provider-specific SqlBuilder and baked into the generated source as const string fields, so each database can be tuned independently and the runtime carries no SQL.

Documentation lives in the DocFX site (docs/site/) — getting-started, features, per-dialect notes, the architecture deep-dive, security, and an auto-generated API reference, plus a Develop area with project status and the roadmap. The published site lives at https://ignytesoftware.github.io/inquiry/ (deployed by docs.yml on every push to main); preview locally with docfx docs/site/docfx.json --serve (see docs/site/README.md).

• New here? Getting started · How it works
• Reference: Features · Providers · Security · Architecture
• Project state: Project status · Roadmap · Contributing

Repository layout

Quickstart

using Inquiry;
using Inquiry.Entities;
using Inquiry.Stores;

[InquiryTable("TOrganization")]
public sealed class Organization
{
    [InquiryKey] public Guid Key { get; set; } = Guid.NewGuid();
    [InquiryColumn("Name")] public string Name { get; set; } = string.Empty;
    [InquiryColumn] public bool IsActive { get; set; } = true;
}

public partial class OrganizationStore : InquiryStore<Organization>
{
    [InquirySelectAll]
    public partial IAsyncEnumerable<Organization> SelectAllAsync(CancellationToken ct = default);

    [InquirySelectOneByKey]
    public partial Task<Organization?> SelectByKeyAsync(Guid key, CancellationToken ct = default);

    [InquiryInsert]
    public partial Task<int> InsertAsync(Organization o, CancellationToken ct = default);
}

Register Inquiry with a provider and resolve the store:

using Inquiry.DependencyInjection;
using Inquiry.Sqlite.DependencyInjection;

services.AddInquiry();                 // core runtime services
services.AddInquiryGeneratedStores();  // stores generated in this assembly
services.AddInquirySqlite(connectionString);

var orgs = sp.GetRequiredService<OrganizationStore>();
await foreach (var o in orgs.SelectAllAsync()) { /* ... */ }

The method bodies, the SQL const strings, the materializers, and the DI wiring are all generated at build time. Beyond this core CRUD surface, Inquiry supports richer WHERE predicates, ORDER BY + offset/keyset pagination, batch & bulk operations, projections + aggregations, eager loading (incl. many-to-many through a junction), optimistic concurrency, soft deletes, global query filters, full-text search, JSON/value-converter columns, JSON-path predicate querying, CREATE TABLE schema-DDL generation, opt-in observability (OpenTelemetry tracing + metrics and ILogger logging via AddInquiryTelemetry()), and open-time resiliency (cloud transient retry + backup-server failover). See How it works and the Architecture deep-dive for the full compile-time pipeline, SQL-building, and runtime walkthrough.

Running the sample

dotnet run --project samples\Inquiry.Sample\Inquiry.Sample.csproj

The sample seeds a database (SQLite by default; configurable to SQL Server or PostgreSQL via Inquiry:Provider), serves a Blazor Server dashboard at /, and exercises CRUD, upsert, eager loading, and a transactional insert.

Running the tests

dotnet test

Tests cover parameter binding, the request pipeline, transactions, generator emission, per-dialect SQL strings, end-to-end CRUD/eager-loading against in-memory SQLite, and — for every provider — live CRUD, schema-fidelity, and generated-DDL verification against the real engine.

The SQL Server, PostgreSQL, MySQL, MariaDB, and Oracle integration suites provision their engine with Testcontainers — the only host dependency is Docker. When Docker is unavailable every live fact skips (via SkippableFact) rather than failing, so dotnet test stays green without Docker. Required CI runs all five server providers with Docker required on pull requests into main. See Project status for the current state and the Roadmap for what's next.

Installing

Packages ship on nuget.org under the Ignyte. prefix (assemblies and namespaces remain Inquiry.*). Install the provider you need — it pulls in the core Ignyte.Inquiry package:

dotnet add package Ignyte.Inquiry.Sqlite      # or .SqlServer / .PostgreSql / .MySql / .MariaDb / .Oracle
dotnet add package Ignyte.Inquiry.Aspire      # optional Aspire client integration
dotnet add package Ignyte.Inquiry.Testing     # optional test helpers

Contributing and releasing

See CONTRIBUTING.md for the full workflow. In short: feature branches PR into main (trunk-based); releases are tag-driven — a maintainer pushes vX.Y.Z for a stable or vX.Y.Z-preview.N for a preview, and release.yml packs, verifies, and publishes to nuget.org. The tag must match the version in eng/release-manifest.json, so every release starts with a reviewed manifest-bump PR. See Contributing — Releasing for the package verifier details.