Updated dependencies and core implementation.

Author: IvanMurzak

.vscode/settings.json

@@ -56,5 +56,8 @@
         "temp/": true,
         "Temp/": true
     },
-    "dotnet.defaultSolution": "Unity-EntityFrameworkCore-SQLite.sln"
+    "dotnet.defaultSolution": "Unity-EntityFrameworkCore-SQLite.sln",
+    "cSpell.words": [
+        "efcore"
+    ]
 }

Assets/_PackageRoot/Documentation~/README.md

@@ -7,7 +7,9 @@ Ready to go bundle package that includes references on [EntityFrameworkCore](htt
 - ✔️ Windows
 - ✔️ Android
 - ✔️ iOS
--  MacOS (need to test)
+-  MacOS (not yet tested)
+
+Supports AOT an JIT compilation. For AOT it uses `link.xml` file to exclude required classes from stripping.
 
 # Usage
 
@@ -26,3 +28,60 @@ SQLitePCLRaw.Startup.Setup();
 ``` CLI
 openupm add extensions.unity.bundle.efcore.sqlite
 ```
+
+# Alternative usage
+
+## 1. Create `SQLiteContext` class
+
+```C#
+using Microsoft.EntityFrameworkCore;
+
+public class SQLiteContext : DbContext
+{
+    // sample table of levels in your database
+    public DbSet<LevelData> Levels { get; set; }
+
+    public SQLiteContext() : base() { }
+    public SQLiteContext(DbContextOptions<SQLiteContext> options) : base(options) { }
+
+    protected override void OnModelCreating(ModelBuilder builder)
+    {
+        base.OnModelCreating(builder);
+        builder.Entity<LevelData>();
+    }
+}
+```
+
+## 2. Create `SQLiteContextFactory` class
+
+```C#
+using Microsoft.EntityFrameworkCore;
+
+public class SQLiteContextFactory : EFCoreSQLiteBundle.SQLiteContextFactory<SQLiteContext>
+{
+    protected override string DesignTimeDataSource => "replace it with path to design time database";
+
+    public SQLiteContextFactory() : base(UnityEngine.Application.persistentDataPath, "data.db") { }
+
+    protected override SQLiteContext InternalCreateDbContext(DbContextOptions<SQLiteContext> optionsBuilder)
+        => new SQLiteContext(optionsBuilder);
+}
+```
+
+The `EFCoreSQLiteBundle.SQLiteContextFactory` class under the hood executes `SQLitePCLRaw.Startup.Setup();` for proper SQLite setup depends on the current platform.
+
+## 3. Create database context
+
+```C#
+var contextFactory = new SQLiteContextFactory();
+var dbContext = contextFactory.CreateDbContext();
+
+// use it for data manipulations
+// sample:
+var level_1 = dbContext.Levels.FirstOrDefault(level => level.id == 1);
+```
+
+# Helpful information
+
+Read more how to use [EntityFrameworkCore](https://learn.microsoft.com/en-us/ef/ef6/get-started?redirectedfrom=MSDN). My favorite approach is `Code First`.
+Please keep in mind because of Unity's .NET Standard 2.1 restrictions we are only limited to use the old version of EntityFrameworkCore 5.0.17. Newer versions require newer .NET version which Unity doesn't support yet. Anyway the version 5.0.17 is a good one for sure!

Assets/_PackageRoot/Plugins/SQLitePCLRaw.provider.sqlite3.2.1.10/netstandard2.0.meta

@@ -7,7 +7,9 @@ Ready to go bundle package that includes references on [EntityFrameworkCore](htt
 - ✔️ Windows
 - ✔️ Android
 - ✔️ iOS
--  MacOS (need to test)
+-  MacOS (not yet tested)
+
+Supports AOT an JIT compilation. For AOT it uses `link.xml` file to exclude required classes from stripping.
 
 # Usage
 
@@ -26,3 +28,60 @@ SQLitePCLRaw.Startup.Setup();
 ``` CLI
 openupm add extensions.unity.bundle.efcore.sqlite
 ```
+
+# Alternative usage
+
+## 1. Create `SQLiteContext` class
+
+```C#
+using Microsoft.EntityFrameworkCore;
+
+public class SQLiteContext : DbContext
+{
+    // sample table of levels in your database
+    public DbSet<LevelData> Levels { get; set; }
+
+    public SQLiteContext() : base() { }
+    public SQLiteContext(DbContextOptions<SQLiteContext> options) : base(options) { }
+
+    protected override void OnModelCreating(ModelBuilder builder)
+    {
+        base.OnModelCreating(builder);
+        builder.Entity<LevelData>();
+    }
+}
+```
+
+## 2. Create `SQLiteContextFactory` class
+
+```C#
+using Microsoft.EntityFrameworkCore;
+
+public class SQLiteContextFactory : EFCoreSQLiteBundle.SQLiteContextFactory<SQLiteContext>
+{
+    protected override string DesignTimeDataSource => "replace it with path to design time database";
+
+    public SQLiteContextFactory() : base(UnityEngine.Application.persistentDataPath, "data.db") { }
+
+    protected override SQLiteContext InternalCreateDbContext(DbContextOptions<SQLiteContext> optionsBuilder)
+        => new SQLiteContext(optionsBuilder);
+}
+```
+
+The `EFCoreSQLiteBundle.SQLiteContextFactory` class under the hood executes `SQLitePCLRaw.Startup.Setup();` for proper SQLite setup depends on the current platform.
+
+## 3. Create database context
+
+```C#
+var contextFactory = new SQLiteContextFactory();
+var dbContext = contextFactory.CreateDbContext();
+
+// use it for data manipulations
+// sample:
+var level_1 = dbContext.Levels.FirstOrDefault(level => level.id == 1);
+```
+
+# Helpful information
+
+Read more how to use [EntityFrameworkCore](https://learn.microsoft.com/en-us/ef/ef6/get-started?redirectedfrom=MSDN). My favorite approach is `Code First`.
+Please keep in mind because of Unity's .NET Standard 2.1 restrictions we are only limited to use the old version of EntityFrameworkCore 5.0.17. Newer versions require newer .NET version which Unity doesn't support yet. Anyway the version 5.0.17 is a good one for sure!

Assets/_PackageRoot/Plugins/SQLitePCLRaw.provider.sqlite3.2.1.10/netstandard2.0/SQLitePCLRaw.provider.sqlite3.dll

@@ -0,0 +1,3 @@
+{
+	"name": "EFCore.SQLite.Bundle"
+}

Assets/_PackageRoot/Plugins/SQLitePCLRaw.provider.sqlite3.2.1.10/netstandard2.0/SQLitePCLRaw.provider.sqlite3.dll.meta

@@ -2,38 +2,55 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Design;
 
-namespace Microsoft.EntityFrameworkCore
+namespace EFCoreSQLiteBundle
 {
     public abstract class SQLiteContextFactory<T> : IDbContextFactory<T>, IDesignTimeDbContextFactory<T> where T : DbContext
     {
-        protected abstract string FolderPath_runtime { get; }
-        protected abstract string FolderPath_designTime { get; }
-        protected virtual string DatabasePath_designTime => $"Data Source={FolderPath_designTime}/data.db";
-        protected virtual string DatabasePath_runtime => $"Data Source={FolderPath_runtime}/data.db";
+        /// <summary>
+        /// The "design time" is only needed in the case if you would like to use the EF Core tools
+        /// For example, to create a migration or update the database schema.
+        /// If you don't need to use the EF Core tools, you can return null here.
+        ///
+        /// Provide the connection string for design time usage.
+        /// It should be something like "Data Source=database.db"
+        /// </summary>
+        protected abstract string DesignTimeDataSource { get; }
+        protected virtual string DataSource => $"Data Source={_dataSource}";
 
+        private readonly string _dataSource;
+        private readonly string _directoryPath;
+
+        /// <summary>
+        /// Default constructor needed for Design Time.
+        /// Don't use it in runtime.
+        /// </summary>
         public SQLiteContextFactory()
         {
             SQLitePCLRaw.Startup.Setup();
         }
-        public SQLiteContextFactory(string folderPath) : this()
+        public SQLiteContextFactory(string directoryPath, string databaseFilename)
         {
-            EnsureDatabaseFolderExists(folderPath);
+            _directoryPath = directoryPath;
+            _dataSource = Path.Combine(directoryPath, databaseFilename);
+            EnsureDatabaseFolderExists();
+
+            SQLitePCLRaw.Startup.Setup();
         }
-        private void EnsureDatabaseFolderExists(string folderPath)
+        private void EnsureDatabaseFolderExists()
         {
-            if (!Directory.Exists(folderPath))
-                Directory.CreateDirectory(folderPath);
+            if (!Directory.Exists(_directoryPath))
+                Directory.CreateDirectory(_directoryPath);
         }
 
         protected abstract T InternalCreateDbContext(DbContextOptions<T> optionsBuilder);
 
         // Runtime usage
         public T CreateDbContext()
         {
-            EnsureDatabaseFolderExists(FolderPath_runtime);
+            EnsureDatabaseFolderExists();
 
             var optionsBuilder = new DbContextOptionsBuilder<T>()
-                .UseSqlite(DatabasePath_runtime);
+                .UseSqlite(DataSource);
 
             var dbContext = InternalCreateDbContext(optionsBuilder.Options);
 
@@ -45,10 +62,8 @@ public T CreateDbContext()
         // Only design time usage
         T IDesignTimeDbContextFactory<T>.CreateDbContext(string[] args)
         {
-            EnsureDatabaseFolderExists(FolderPath_designTime);
-
             var optionsBuilder = new DbContextOptionsBuilder<T>()
-                .UseSqlite(DatabasePath_designTime);
+                .UseSqlite(DesignTimeDataSource);
 
             return InternalCreateDbContext(optionsBuilder.Options);
         }