docs: removed README artifacts from previous update. Updated sqlproj references (#18)

Author: JerrettDavis

QUICKSTART.md

@@ -27,7 +27,9 @@ dotnet build
 ```
 MySolution/
 ├── src/MyApp/MyApp.csproj
-└── database/MyDb/MyDb.sqlproj
+└── database/MyDb/
+    └── MyDb.sqlproj          # Microsoft.Build.Sql
+    # OR MyDb.csproj           # MSBuild.Sdk.SqlProj
 ```
 
 **MyApp.csproj:**
@@ -38,6 +40,8 @@ MySolution/
 
 <PropertyGroup>
   <EfcptSqlProj>..\..\database\MyDb\MyDb.sqlproj</EfcptSqlProj>
+  <!-- For Microsoft.Build.Sql, use .sqlproj -->
+  <!-- For MSBuild.Sdk.SqlProj, use .csproj or .fsproj -->
 </PropertyGroup>
 ```
 
@@ -154,6 +158,7 @@ Templates automatically staged to `obj/efcpt/Generated/CodeTemplates/`
 ```xml
 <PropertyGroup>
   <EfcptSqlProj>..\..\database\MyDb\MyDb.sqlproj</EfcptSqlProj>
+  <!-- For Microsoft.Build.Sql, use .sqlproj; for MSBuild.Sdk.SqlProj, use .csproj/.fsproj -->
 </PropertyGroup>
 ```
 
@@ -288,8 +293,9 @@ dotnet tool restore
 
 **Quick Fix:**
 ```bash
-# Test database project independently
+# Test SQL Project independently
 dotnet build path\to\Database.sqlproj
+# Or for MSBuild.Sdk.SqlProj: dotnet build path\to\Database.csproj
 ```
 
 ### Issue: Old schema still generating
@@ -319,7 +325,7 @@ dotnet build
 
 | Property | Use When | Example |
 |----------|----------|---------|
-| `EfcptSqlProj` | Database project not auto-discovered | `..\..\db\MyDb.sqlproj` |
+| `EfcptSqlProj` | SQL Project not auto-discovered | `..\..\db\MyDb.sqlproj` or `..\..\db\MyDb.csproj` |
 | `EfcptConfig` | Using custom config file name | `my-config.json` |
 | `EfcptTemplateDir` | Using custom template location | `CustomTemplates` |
 | `EfcptLogVerbosity` | Debugging issues | `detailed` |
@@ -422,10 +428,12 @@ YourProject/
 
 <PropertyGroup Condition="'$(Environment)' == 'Development'">
   <EfcptSqlProj>..\..\database\Dev\Dev.sqlproj</EfcptSqlProj>
+  <!-- Or Dev.csproj for MSBuild.Sdk.SqlProj -->
 </PropertyGroup>
 
 <PropertyGroup Condition="'$(Environment)' == 'Production'">
   <EfcptSqlProj>..\..\database\Prod\Prod.sqlproj</EfcptSqlProj>
+  <!-- Or Prod.csproj for MSBuild.Sdk.SqlProj -->
 </PropertyGroup>
 ```
 
@@ -444,6 +452,7 @@ YourProject/
 <PropertyGroup>
   <!-- Project-specific override -->
   <EfcptSqlProj>..\..\database\MyDb\MyDb.sqlproj</EfcptSqlProj>
+  <!-- For Microsoft.Build.Sql, use .sqlproj; for MSBuild.Sdk.SqlProj, use .csproj/.fsproj -->
 </PropertyGroup>
 ```
 

README.md

@@ -19,8 +19,8 @@ Set these properties in your `.csproj` file or `Directory.Build.props`.
 | Property | Default | Description |
 |----------|---------|-------------|
 | `EfcptEnabled` | `true` | Master switch for the entire pipeline |
-| `EfcptSqlProj` | *(auto-discovered)* | Path to `.sqlproj` file |
-| `EfcptDacpac` | *(empty)* | Path to pre-built `.dacpac` file (skips .sqlproj build) |
+| `EfcptSqlProj` | *(auto-discovered)* | Path to SQL Project file (`.sqlproj` for Microsoft.Build.Sql, `.csproj`/`.fsproj` for MSBuild.Sdk.SqlProj) |
+| `EfcptDacpac` | *(empty)* | Path to pre-built `.dacpac` file (skips SQL Project build) |
 | `EfcptConfig` | `efcpt-config.json` | EF Core Power Tools configuration file |
 | `EfcptRenaming` | `efcpt.renaming.json` | Renaming rules file |
 | `EfcptTemplateDir` | `Template` | T4 template directory |

docs/user-guide/configuration.md

@@ -20,14 +20,14 @@ The pipeline consists of seven stages that run before C# compilation:
 **Purpose**: Discover the database source and locate all configuration files.
 
 **What it does**:
-- Locates the SQL Server Database Project (.sqlproj) from project references or explicit configuration
+- Locates the SQL Project from project references or explicit configuration
 - Resolves the EF Core Power Tools configuration file (`efcpt-config.json`)
 - Finds renaming rules (`efcpt.renaming.json`)
 - Discovers T4 template directories
 - Resolves connection strings from various sources (explicit property, appsettings.json, app.config)
 
 **Outputs**:
-- `SqlProjPath` - Path to the discovered database project
+- `SqlProjPath` - Path to the discovered SQL Project
 - `ResolvedConfigPath` - Path to the configuration file
 - `ResolvedRenamingPath` - Path to renaming rules
 - `ResolvedTemplateDir` - Path to templates
@@ -37,8 +37,8 @@ The pipeline consists of seven stages that run before C# compilation:
 
 **Purpose**: Prepare the schema source for code generation.
 
-**DACPAC Mode** (when using .sqlproj):
-- Builds the SQL Server Database Project to produce a DACPAC file
+**DACPAC Mode** (when using SQL Project):
+- Builds the SQL Project to produce a DACPAC file
 - Only rebuilds if source files are newer than the existing DACPAC
 - Uses `msbuild.exe` on Windows or `dotnet msbuild` on other platforms
 
@@ -200,22 +200,25 @@ For each input type, the package searches in this order:
 
 ### SQL Project Discovery
 
-The package discovers SQL projects by:
+The package discovers SQL Projects by:
 
 1. Checking `EfcptSqlProj` property (if set)
-2. Scanning `ProjectReference` items for .sqlproj files
-3. Looking for .sqlproj in the solution directory
-4. Checking for modern SDK-style SQL projects
+2. Scanning `ProjectReference` items for SQL Projects
+3. Looking for SQL Projects in the solution directory
+4. Checking for modern SDK-style SQL Projects
 
 **Supported SQL Project SDKs:**
 
-| SDK | Cross-Platform | Notes |
-|-----|----------------|-------|
-| [Microsoft.Build.Sql](https://github.com/microsoft/DacFx) | Yes | Microsoft's official SDK-style SQL projects |
-| [MSBuild.Sdk.SqlProj](https://github.com/rr-wfm/MSBuild.Sdk.SqlProj) | Yes | Popular community SDK |
-| Traditional .sqlproj | No (Windows only) | Requires SQL Server Data Tools |
+| SDK | Extension | Cross-Platform | Notes |
+|-----|-----------|----------------|-------|
+| [Microsoft.Build.Sql](https://github.com/microsoft/DacFx) | `.sqlproj` | Yes | Microsoft's official SDK-style SQL Projects for .NET |
+| [MSBuild.Sdk.SqlProj](https://github.com/rr-wfm/MSBuild.Sdk.SqlProj) | `.csproj` or `.fsproj` | Yes | Community SDK with additional features and extensibility |
+| Traditional SQL Projects | `.sqlproj` | No (Windows only) | Legacy format, requires SQL Server Data Tools |
 
-Both SDK-style projects work identically - they produce DACPACs that JD.Efcpt.Build uses for code generation.
+**Key Differences:**
+- **Microsoft.Build.Sql** uses the `.sqlproj` extension and is Microsoft's official modern SDK for SQL Projects in .NET SDK
+- **MSBuild.Sdk.SqlProj** uses `.csproj` or `.fsproj` extensions (despite having "SqlProj" in its name), provides more configurability and extensibility
+- Both SDK-style projects produce DACPACs that JD.Efcpt.Build uses for code generation
 
 ## Generated File Naming
 

docs/user-guide/core-concepts.md

@@ -8,7 +8,7 @@ Before you begin, ensure you have:
 
 - **.NET SDK 8.0 or later** installed
 - One of:
-  - A **SQL Server Database Project** (.sqlproj) that produces a DACPAC
+  - A **SQL Server Database Project** that produces a DACPAC
   - A live database connection (SQL Server, PostgreSQL, MySQL, SQLite, Oracle, Firebird, or Snowflake)
 - Basic familiarity with MSBuild and NuGet
 
@@ -65,7 +65,7 @@ dotnet build
 
 On the first build, the package will:
 
-1. Discover your SQL Server Database Project
+1. Discover your SQL Project
 2. Build it to a DACPAC
 3. Run the EF Core Power Tools CLI
 4. Generate DbContext and entity classes
@@ -95,26 +95,29 @@ YourSolution/
 │       └── efcpt-config.json       # Optional: customize generation
 └── database/
     └── YourDatabase/
-        └── YourDatabase.sqlproj    # Your database project
+        └── YourDatabase.sqlproj    # Your SQL Project (Microsoft.Build.Sql)
+                                    # OR YourDatabase.csproj (MSBuild.Sdk.SqlProj)
 ```
 
 ## Minimal Configuration
 
 For most projects, no configuration is required. The package uses sensible defaults:
 
-- Auto-discovers `.sqlproj` in your solution
+- Auto-discovers SQL Project in your solution (`.sqlproj` for Microsoft.Build.Sql, `.csproj`/`.fsproj` for MSBuild.Sdk.SqlProj)
 - Uses `efcpt-config.json` if present
 - Generates to `obj/efcpt/Generated/`
 - Enables nullable reference types
 - Organizes files by database schema
 
-### Explicit Database Project Path
+### Explicit SQL Project Path
 
-If auto-discovery doesn't find your database project, specify it explicitly:
+If auto-discovery doesn't find your SQL Project, specify it explicitly:
 
 ```xml
 <PropertyGroup>
   <EfcptSqlProj>..\database\YourDatabase\YourDatabase.sqlproj</EfcptSqlProj>
+  <!-- For Microsoft.Build.Sql, use .sqlproj extension -->
+  <!-- For MSBuild.Sdk.SqlProj, use .csproj or .fsproj extension -->
 </PropertyGroup>
 ```
 
@@ -146,7 +149,7 @@ Create `efcpt-config.json` in your project directory to customize generation:
 
 ## Using a Live Database
 
-If you don't have a .sqlproj, you can generate models directly from a database connection. JD.Efcpt.Build supports multiple database providers:
+If you don't have a SQL Project, you can generate models directly from a database connection. JD.Efcpt.Build supports multiple database providers:
 
 | Provider | Value | Example |
 |----------|-------|---------|
@@ -237,7 +240,7 @@ dotnet build
 
 ### Database project not found
 
-If the package can't find your .sqlproj:
+If the package can't find your SQL Project:
 
 1. Ensure the project exists and builds independently
 2. Set `EfcptSqlProj` explicitly in your .csproj

docs/user-guide/getting-started.md

@@ -10,14 +10,14 @@ JD.Efcpt.Build eliminates this manual step by:
 
 - **Automating code generation** during `dotnet build`
 - **Detecting schema changes** using fingerprinting to avoid unnecessary regeneration
-- **Supporting multiple input sources** including SQL Server Database Projects (.sqlproj) and live database connections
+- **Supporting multiple input sources** including SQL Projects and live database connections
 - **Enabling CI/CD workflows** where models are generated consistently on any build machine
 
 ## When to Use JD.Efcpt.Build
 
 Use this package when:
 
-- You have a SQL Server database described by a Database Project (`.sqlproj`) and want EF Core models generated automatically
+- You have a SQL Server database described by a SQL Project and want EF Core models generated automatically
 - You want EF Core Power Tools generation to run as part of `dotnet build` instead of being a manual step
 - You need deterministic, source-controlled model generation that works identically on developer machines and in CI/CD
 - You're working in a team environment and need consistent code generation across developers
@@ -74,13 +74,13 @@ Models are only regenerated when this fingerprint changes, making subsequent bui
 
 ### Dual Input Modes
 
-**DACPAC Mode** (Default): Works with SQL Server Database Projects
-- Automatically builds your .sqlproj to a DACPAC
+**DACPAC Mode** (Default): Works with SQL Projects
+- Automatically builds your SQL Project to a DACPAC
 - Generates models from the DACPAC schema
 
 **Connection String Mode**: Works with live databases
 - Connects directly to a database server
-- No .sqlproj required
+- No SQL Project required
 - Ideal for cloud databases or existing production systems
 
 ### Smart Discovery

docs/user-guide/index.md

@@ -6,35 +6,40 @@ This directory contains sample projects demonstrating various usage patterns of
 
 | Sample | Input Mode | SQL SDK / Provider | Key Features |
 |--------|------------|-------------------|--------------|
-| [simple-generation](#simple-generation) | DACPAC | Traditional .sqlproj | Basic usage, direct source import |
-| [msbuild-sdk-sql-proj-generation](#msbuild-sdk-sql-proj-generation) | DACPAC | MSBuild.Sdk.SqlProj | Modern cross-platform SQL SDK |
-| [split-data-and-models-between-multiple-projects](#split-outputs) | DACPAC | Traditional .sqlproj | Clean architecture, split outputs |
+| [simple-generation](#simple-generation) | DACPAC | Traditional SQL Project (.sqlproj) | Basic usage, direct source import |
+| [msbuild-sdk-sql-proj-generation](#msbuild-sdk-sql-proj-generation) | DACPAC | MSBuild.Sdk.SqlProj (.csproj) | Modern cross-platform SQL SDK |
+| [split-data-and-models-between-multiple-projects](#split-outputs) | DACPAC | Traditional SQL Project (.sqlproj) | Clean architecture, split outputs |
 | [connection-string-sqlite](#connection-string-sqlite) | Connection String | SQLite | Direct database reverse engineering |
 
 ## Input Modes
 
 JD.Efcpt.Build supports two primary input modes:
 
 ### 1. DACPAC Mode (Default)
-Reverse engineers from a SQL Server Database Project that produces a .dacpac file.
+Reverse engineers from a SQL Project that produces a .dacpac file.
 
-JD.Efcpt.Build supports multiple SQL project SDKs:
+JD.Efcpt.Build supports multiple SQL Project SDKs:
 
-| SDK | Cross-Platform | Notes |
-|-----|----------------|-------|
-| [Microsoft.Build.Sql](https://github.com/microsoft/DacFx) | Yes | Microsoft's official SDK-style SQL projects |
-| [MSBuild.Sdk.SqlProj](https://github.com/rr-wfm/MSBuild.Sdk.SqlProj) | Yes | Popular community SDK for cross-platform builds |
-| Traditional .sqlproj | No (Windows only) | Requires SQL Server Data Tools |
+| SDK | Extension | Cross-Platform | Notes |
+|-----|-----------|----------------|-------|
+| [Microsoft.Build.Sql](https://github.com/microsoft/DacFx) | `.sqlproj` | Yes | Microsoft's official SDK-style SQL Projects for .NET |
+| [MSBuild.Sdk.SqlProj](https://github.com/rr-wfm/MSBuild.Sdk.SqlProj) | `.csproj` or `.fsproj` | Yes | Community SDK with additional features and extensibility |
+| Traditional SQL Projects | `.sqlproj` | No (Windows only) | Legacy format, requires SQL Server Data Tools |
 
 ```xml
 <ItemGroup>
   <ProjectReference Include="..\Database\Database.sqlproj">
     <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
   </ProjectReference>
+  <!-- Use .sqlproj for Microsoft.Build.Sql -->
+  <!-- Use .csproj or .fsproj for MSBuild.Sdk.SqlProj -->
 </ItemGroup>
 ```
 
-Both SDK-style projects work identically with JD.Efcpt.Build - the package automatically detects and builds them.
+**Key Differences:**
+- **Microsoft.Build.Sql** uses `.sqlproj` extension and is Microsoft's official SDK
+- **MSBuild.Sdk.SqlProj** uses `.csproj`/`.fsproj` extension (despite having "SqlProj" in its name)
+- Both produce DACPACs and work identically with JD.Efcpt.Build
 
 ### 2. Connection String Mode
 Reverse engineers directly from a live database connection.
@@ -70,8 +75,8 @@ Basic sample demonstrating DACPAC-based model generation with direct source impo
 
 ```
 simple-generation/
-├── DatabaseProject/          # SQL Server Database Project
-│   └── DatabaseProject.sqlproj
+├── DatabaseProject/          # SQL Project
+│   └── DatabaseProject.sqlproj  # Traditional format
 ├── EntityFrameworkCoreProject/
 │   ├── EntityFrameworkCoreProject.csproj
 │   ├── efcpt-config.json
@@ -90,24 +95,24 @@ dotnet build simple-generation/SimpleGenerationSample.sln
 
 **Location:** `msbuild-sdk-sql-proj-generation/`
 
-Demonstrates using a modern SDK-style SQL project (MSBuild.Sdk.SqlProj) for cross-platform DACPAC builds. This sample works on Windows, Linux, and macOS.
+Demonstrates using MSBuild.Sdk.SqlProj for cross-platform DACPAC builds. This SDK uses `.csproj` extension (not `.sqlproj`).
 
 ```
 msbuild-sdk-sql-proj-generation/
 ├── DatabaseProject/          # MSBuild.Sdk.SqlProj project
-│   └── DatabaseProject.csproj
+│   └── DatabaseProject.csproj   # Uses .csproj extension
 ├── EntityFrameworkCoreProject/
 │   ├── EntityFrameworkCoreProject.csproj
 │   └── efcpt-config.json
 └── SimpleGenerationSample.sln
 ```
 
 **Key Features:**
-- Uses `MSBuild.Sdk.SqlProj` SDK for the database project (cross-platform)
-- Works identically to traditional .sqlproj but runs on any OS
-- Dynamic SQL project discovery (no explicit reference needed)
+- Uses `MSBuild.Sdk.SqlProj` SDK for the SQL Project (note: uses `.csproj` extension)
+- Works on Windows, Linux, and macOS
+- Dynamic SQL Project discovery (no explicit reference needed)
 
-> **Note:** You can also use `Microsoft.Build.Sql` SDK, which is Microsoft's official SDK-style SQL project format. Both SDKs are fully supported.
+> **Note:** Despite having "SqlProj" in its name, MSBuild.Sdk.SqlProj uses `.csproj` or `.fsproj` extensions, not `.sqlproj`.
 
 ---
 
@@ -120,7 +125,7 @@ Advanced sample showing how to split generated output across multiple projects f
 ```
 split-data-and-models-between-multiple-projects/
 └── src/
-    ├── SampleApp.Sql/       # SQL Database Project
+    ├── SampleApp.Sql/       # SQL Project (Microsoft.Build.Sql format)
     ├── SampleApp.Models/    # Entity classes only (NO EF Core)
     └── SampleApp.Data/      # DbContext + EF Core dependencies
 ```
@@ -145,7 +150,7 @@ split-data-and-models-between-multiple-projects/
 
 **Location:** `connection-string-sqlite/`
 
-Demonstrates connection string mode with SQLite - no SQL project needed, reverse engineers directly from a database.
+Demonstrates connection string mode with SQLite - no SQL Project needed, reverse engineers directly from a database.
 
 ```
 connection-string-sqlite/

samples/README.md

@@ -1,10 +1,25 @@
-# Simple Generation Sample
+# MSBuild.Sdk.SqlProj Generation Sample
 
-This sample demonstrates using `JD.Efcpt.Build` to generate EF Core models from a SQL Server Database Project.
+This sample demonstrates using `JD.Efcpt.Build` with the **[MSBuild.Sdk.SqlProj](https://github.com/rr-wfm/MSBuild.Sdk.SqlProj)** SDK.
+
+## Key Differences from Microsoft.Build.Sql
+
+**MSBuild.Sdk.SqlProj**:
+- Uses `.csproj` or `.fsproj` file extension (not `.sqlproj`)
+- Community-maintained SDK with additional features and extensibility
+- Cross-platform: works on Linux/macOS/Windows
+- More similar to the legacy .NET Framework SQL Projects
+
+**Microsoft.Build.Sql**:
+- Uses `.sqlproj` file extension
+- Microsoft's official SDK for SQL Projects in .NET SDK
+- Cross-platform: works on Linux/macOS/Windows
+
+Both produce DACPACs that work with JD.Efcpt.Build.
 
 ## Project Structure
 
-- `DatabaseProject/` - SQL Server Database Project that defines the schema
+- `DatabaseProject/` - MSBuild.Sdk.SqlProj project (uses `.csproj` extension)
 - `EntityFrameworkCoreProject/` - .NET project that consumes the generated EF Core models
 
 ## How It Works