SoloTable.CodeGen 0.1.0-preview.1

SoloTable

Schema sync and scaffold for .NET 8 and .NET 9 — code-first one table at a time, DB-first single or multi-table (including EF Core models).

Install one provider package, connect with its facade, then either:

Current release: 0.1.0-preview — suitable for evaluation and early adoption. APIs may still change before 1.0.

Author: Pankaj Jadhav · GitHub · License: MIT

Install

Pick only the database you use:

dotnet add package SoloTable.Sqlite
dotnet add package SoloTable.MySql        # MySQL + MariaDB
dotnet add package SoloTable.PostgreSql
dotnet add package SoloTable.SqlServer
dotnet add package SoloTable.Oracle
dotnet add package SoloTable.Firebird

Preview packages require a matching version (or --prerelease):

dotnet add package SoloTable.MySql --version 0.1.0-preview.1

Connection strings

SQLite:      Data Source=app.db
MySQL:       Server=localhost;Port=3306;Database=mydb;Uid=root;Pwd=secret;
PostgreSQL:  Host=localhost;Port=5432;Database=mydb;Username=postgres;Password=secret
SQL Server:  Server=localhost;Database=mydb;Trusted_Connection=True;TrustServerCertificate=True
Oracle:      User Id=scott;Password=tiger;Data Source=localhost:1521/XEPDB1
Firebird:    Database=app.fdb;User=SYSDBA;Password=masterkey;DataSource=localhost

Code-first (C# → database)

Create or alter one table from a CLR type or a fluent definition.

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using SoloTable;
using SoloTable.MySql; // or Sqlite / PostgreSql / SqlServer / ...

[Table("Orders")]
public class Order
{
    [Key]
    public long Id { get; set; }

    [Required, MaxLength(100)]
    public string CustomerName { get; set; } = "";
}

var db = MySqlFacade.Connect(
    "Server=localhost;Port=3306;Database=mydb;Uid=root;Pwd=secret;");

// From entity type
await db.CodeFirst().Entity<Order>().SyncAsync();

// One-shot helper
await db.CodeFirst().EnsureAsync<Order>();

// Fluent definition (no entity class required)
await db.CodeFirst()
    .Table("Orders")
    .Define(t => t
        .Column("Id", ColumnDbType.Int64, c => c.PrimaryKey(identity: true))
        .Column("CustomerName", ColumnDbType.String, c => c.NotNull().MaxLength(100))
        .Column("Notes", ColumnDbType.String, c => c.Nullable()))
    .SyncAsync();

// Dry-run: generate SQL without executing
var sql = await db.CodeFirst().Entity<Order>().GenerateScriptAsync();

Adding a property on Order and calling SyncAsync() again only alters that table (additive by default).

DB-first (database → C#)

Single table (POCO)

Inspect or scaffold a partial POCO from one existing table. Writing one file never deletes others.

var db = MySqlFacade.Connect(connectionString);

var live = await db.DbFirst().Table("Orders").InspectAsync();

var scaffold = await db.DbFirst()
    .Table("Orders")
    .Scaffold()
    .WithNamespace("MyApp.Models")
    .WithDataAnnotations()
    .GenerateAsync();

Console.WriteLine(scaffold.SourceCode);

await db.DbFirst()
    .Table("Orders")
    .GenerateToFileAsync("Orders.cs");

db.Scaffold("Orders") is a shorthand for db.DbFirst().Table("Orders").Scaffold().

EF Core model (partial entities + DbContext + Fluent API)

Generated code targets EF Core. Add Microsoft.EntityFrameworkCore and your EF database provider in the consuming app.

Multi-table — entities + DbContext / OnModelCreating:

await db.DbFirst()
    .Tables("Customers", "Orders")   // or .Schema() for all tables
    .ScaffoldEf()
    .WithNamespace("MyApp.Data")
    .WithContextName("AppDbContext")
    .WithDataAnnotations()
    .GenerateToDirectoryAsync("./Generated");

Single-table EF scaffold is additive — updates only that entity file; does not overwrite or delete other entities or an existing DbContext:

await db.DbFirst()
    .Table("Orders")
    .ScaffoldEf()          // GenerateContext = false by default
    .WithNamespace("MyApp.Data")
    .GenerateToDirectoryAsync("./Generated");

// Opt in if you really want a one-table DbContext written:
await db.DbFirst().Table("Orders").ScaffoldEf().WithContext().GenerateToDirectoryAsync("./Generated");

GenerateToDirectoryAsync only writes files produced by the current run; it never clears the folder.

Consumers still need EF packages, for example:

dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Pomelo.EntityFrameworkCore.MySql   # or Npgsql / SqlServer / ...

Round-trip

await db.CodeFirst().EnsureAsync<Order>();
await db.DbFirst().Table("Orders").GenerateToFileAsync("Generated/Order.cs");

Safety defaults

SoloTable code-first targets only the named table:

• Never emits DROP TABLE
• Never mutates other tables
• DROP COLUMN and other destructive changes are skipped unless you opt in:

await db.CodeFirst()
    .Entity<Order>()
    .WithOptions(o => o.AllowDestructive = true)
    .SyncAsync();

Dry-run / script generation never executes DDL:

.WithOptions(o => o.DryRun = true)
// or
.GenerateScriptAsync()

More detail: Safety policy on GitHub

Target frameworks

• net8.0
• net9.0

Design notes

• Facade pattern — engines and dialects stay internal.
• Release builds — assemblies are obfuscated; symbol packages are not published.
• Install one provider per app; do not install every SoloTable.* package unless you need multiple databases.
• Code-first remains one table per sync call; DB-first can scaffold one or many tables into EF models.

Docs: NuGet setup · Providers · Testing · Protection · Publish