Fix aot mac #1609
Fix aot mac #1609
Conversation
|
Important Review skippedAuto incremental reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the You can disable this status message by setting the 📝 WalkthroughWalkthroughThis update introduces a comprehensive set of auto-generated files that define runtime Entity Framework Core (EF Core) model configurations for various entities in the backend, including properties, keys, indexes, foreign keys, and relational annotations. JSON serialization is now handled via source generation, with new converters and serialization logic applied throughout the model. The Changes
Poem
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. 🪧 TipsChatThere are 3 ways to chat with CodeRabbit:
SupportNeed help? Create a ticket on our support page for assistance with any issues or questions. Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments. CodeRabbit Commands (Invoked using PR comments)
Other keywords and placeholders
CodeRabbit Configuration File (
|
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 1
🧹 Nitpick comments (9)
backend/FwLite/LcmCrdt/CompiledModels/LcmCrdtDbContextModel.cs (1)
13-14: Clarify the purpose of_useOldBehavior31751.
This switch-based logic suggests backward compatibility or a workaround for an EF Core issue. If this setting is only needed temporarily, consider adding inline comments or a TODO marker indicating its planned removal or further review later.backend/FwLite/LcmCrdt/CompiledModels/ProjectDataEntityType.cs (1)
39-45: Consider indexingCodeif frequently used in queries.
IfCodeis essential for lookups or filtering, adding an index could help performance. Otherwise, you may keep it as-is.backend/FwLite/LcmCrdt/CompiledModels/WritingSystemEntityType.cs (1)
22-197: Reevaluate "jsonb" for exemplars in SQLite.
Similar to the discussion inComplexFormTypeEntityType, the"jsonb"store type might be a carryover from PostgreSQL. Although not necessarily harmful in a SQLite environment, it may be unclear to other developers. Consider standardizing the store type to something explicitly SQLite-compatible unless cross-database behavior is a strict requirement.backend/FwLite/LcmCrdt/CompiledModels/PublicationEntityType.cs (1)
116-116: Leverage the partial method
TheCustomize(runtimeEntityType)method can be used to add specialized mappings or concurrency tokens. If customization isn't required, consider removing or documenting this method.backend/FwLite/LcmCrdt/CompiledModels/ChangeEntityEntityType.cs (2)
23-105: Handle invalid JSON gracefully and verify 'jsonb' usage
While using a value converter for serialization is effective, consider adding error handling or fallback logic for invalid JSON data to prevent runtime exceptions. Also confirm that labeling the columnjsonbdoes not cause compatibility issues under SQLite.
138-138: Partial method usage
If no extra custom logic is needed, consider removing or documenting theCustomizepartial method for clarity.backend/FwLite/LcmCrdt/CompiledModels/ExampleSentenceEntityType.cs (1)
207-207: Clarify or remove partial method
IfCustomize(runtimeEntityType)does not require additional logic, consider removing or documenting this partial method to reduce confusion.backend/FwLite/LcmCrdt/CompiledModels/ObjectSnapshotEntityType.cs (1)
132-155: Validate the design of storing theReferencesarray as JSON.
If referential integrity or frequent filtering/ordering on these references is needed, relying on JSON-based storage may limit indexing and complicate queries.backend/FwLite/LcmCrdt/CompiledModels/ComplexFormComponentEntityType.cs (1)
36-43: Check GUID sentinel usage forComplexFormEntryId.This property includes a sentinel
00000000-0000-0000-0000-000000000000for comparisons. Ensure any custom logic in your application does not incorrectly treat the sentinel as valid data, especially if using EF default value behaviors.
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (21)
backend/FwLite/LcmCrdt.Tests/DataModelSnapshotTests.VerifyDbModel.verified.txt(2 hunks)backend/FwLite/LcmCrdt/CompiledModels/ChangeEntityEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/CommitEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/ComplexFormComponentEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/ComplexFormTypeEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/EntryEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/ExampleSentenceEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/LcmCrdtDbContextModel.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/ObjectSnapshotEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/PartOfSpeechEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/ProjectDataEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/PublicationEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/SemanticDomainEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/SenseEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/CompiledModels/WritingSystemEntityType.cs(1 hunks)backend/FwLite/LcmCrdt/Data/CompileModelCustomization.cs(1 hunks)backend/FwLite/LcmCrdt/JsonSourceGenerationContext.cs(1 hunks)backend/FwLite/LcmCrdt/LcmCrdtDbContext.cs(3 hunks)backend/FwLite/LcmCrdt/LcmCrdtKernel.cs(5 hunks)backend/FwLite/Taskfile.yml(1 hunks)backend/harmony(1 hunks)
🧰 Additional context used
🧬 Code Graph Analysis (2)
backend/FwLite/LcmCrdt/CompiledModels/LcmCrdtDbContextModel.cs (3)
backend/FwLite/LcmCrdt/LcmCrdtDbContext.cs (1)
LcmCrdtDbContext(13-67)backend/FwLite/LcmCrdt/CompiledModels/LcmCrdtDbContextModelBuilder.cs (2)
LcmCrdtDbContextModel(15-1513)Initialize(17-67)backend/FwLite/LcmCrdt/Data/CompileModelCustomization.cs (2)
Customize(15-39)Customize(43-81)
backend/FwLite/LcmCrdt/CompiledModels/ComplexFormComponentEntityType.cs (3)
backend/FwLite/LcmCrdt/CompiledModels/ComplexFormTypeEntityType.cs (3)
RuntimeEntityType(20-91)RuntimeForeignKey(93-102)Customize(116-116)backend/FwLite/LcmCrdt/CompiledModels/EntryEntityType.cs (3)
RuntimeEntityType(21-245)RuntimeForeignKey(247-256)Customize(270-270)backend/FwLite/LcmCrdt/Data/CompileModelCustomization.cs (2)
Customize(15-39)Customize(43-81)
⏰ Context from checks skipped due to timeout of 90000ms (4)
- GitHub Check: Build FwHeadless / publish-fw-headless
- GitHub Check: Build API / publish-api
- GitHub Check: Analyze (csharp)
- GitHub Check: Build FW Lite and run tests
🔇 Additional comments (54)
backend/harmony (1)
1-1: Submodule reference update looks good.This file only updates the submodule pointer. Please ensure the referenced commit is tested and compatible with the parent repository, especially given the recent EF Core and AoT changes.
backend/FwLite/Taskfile.yml (1)
36-39: Good addition for AoT compilation support!This new task
compile-db-modelcorrectly sets up the generation of compiled Entity Framework models usingdotnet ef dbcontext optimize. This is an essential step for Ahead-of-Time compilation as it creates source-generated models that don't rely on runtime reflection.backend/FwLite/LcmCrdt/JsonSourceGenerationContext.cs (1)
12-65: Well-structured JSON source generation configurationThis implementation correctly sets up System.Text.Json source generation, which is essential for AoT compilation. You've properly:
- Created a partial class derived from JsonSerializerContext
- Configured all required model types with JsonSerializable attributes
- Set up the minimal options needed for the serialization context
This approach eliminates runtime reflection during JSON serialization/deserialization, which is necessary for AOT compilation on macOS.
backend/FwLite/LcmCrdt/LcmCrdtKernel.cs (6)
93-110: Good addition of explicit Linq2DB conversionsThe additional conversion logic for Linq2DB is necessary since the compiled models aren't being automatically detected. Using the
LcmCrdtDbContextcentralized serialization methods ensures consistency across the application.
128-133: Useful utility method for CrdtConfig creationThis convenience method for creating and configuring a
CrdtConfiginstance promotes code reuse and consistency.
156-162: Consistent serialization approachReplacing direct JsonSerializer calls with the centralized
LcmCrdtDbContext.Serialize/Deserializemethods ensures consistent serialization behavior and proper AoT compatibility.
175-176: Aligned serialization patternGood consistency with the serialization approach used throughout the codebase.
186-186: Good default sentinel valueAdding a sentinel default value for WritingSystemId is a good practice for entity framework relationships.
190-192: Consistent serialization patternUsing the same serialization approach for the Exemplars property maintains consistency.
backend/FwLite/LcmCrdt/LcmCrdtDbContext.cs (3)
21-21: Excellent use of compiled modelUsing the pre-compiled EF Core model instance is crucial for AoT compilation as it eliminates runtime model building.
45-52: Good refactoring of converter classesMaking the converter classes internal and updating them to use the centralized serialization methods is a necessary change for AoT compatibility.
57-66: Well-implemented serialization utilitiesThese centralized serialization methods provide a consistent approach to JSON handling throughout the application. The exception thrown on deserialization failure is a good practice to catch issues early.
backend/FwLite/LcmCrdt/CompiledModels/LcmCrdtDbContextModel.cs (2)
20-34: Review the thread-based initialization approach for potential complexity.
While creating and joining a dedicated thread ensures isolation, it might introduce extra overhead or future concurrency concerns. Consider using aTaskor performing a direct synchronous call instead, unless a separate thread is strictly required.Would you like to confirm whether any unhandled exceptions could occur in the new thread? If so, I can propose a quick script to scan for try-catch handling within the initialization path.
43-45: Ensure partial methodsInitialize()andCustomize()are implemented in companion files.
These partial definitions rely on actual implementations to perform model building and customization. Verify that the corresponding partial methods exist and are properly invoked.backend/FwLite/LcmCrdt.Tests/DataModelSnapshotTests.VerifyDbModel.verified.txt (2)
269-269: Confirm the use ofSentinel:defaultonWsId.
The sentinel value implies a default fallback forWritingSystemId. Double-check that this accurately represents the domain's expected default.
307-313: Validate the relational annotations onHybridDateTime.
Lines 307-313 indicate a complex property with additional relational mapping but no direct table or schema references. Ensure this complex property is correctly persisted and recognized by EF.backend/FwLite/LcmCrdt/CompiledModels/ProjectDataEntityType.cs (2)
14-20: Entity naming consistency looks good.
Using"LcmCrdt.ProjectData"as the entity name aligns well with the domain naming convention. No immediate concerns.
70-76: Check constraints on theNamecolumn.
Currently,Nameis a simplestringwith no specified length or validation. If there's any length limit or data format requirement, consider adding constraints in the domain model or column definition.backend/FwLite/LcmCrdt/CompiledModels/PartOfSpeechEntityType.cs (3)
45-75: JSON-basedNameproperty converter looks robust.
StoringMultiStringas JSON is a neat solution. This approach should maintain flexibility. The customValueCompareralso ensures consistent change tracking.
76-97: Double-check handling of thePredefinedboolean.
By default, its sentinel isfalse. Confirm whether there's any scenario wheretrueshould be used as a default to avoid confusion or data mismatch.
99-103:SnapshotIdusage appears correct.
This nullable GUID property ensures that partial data or dependencies can be softly linked or separated. The unique index andSetNullbehavior is consistent with the rest of the model.backend/FwLite/LcmCrdt/CompiledModels/SemanticDomainEntityType.cs (3)
52-81:Nameproperty leverages a JSON-based multi-string converter.
This is consistent with other entity definitions. The mapping, comparer, and converter approach is well-structured.
83-104:Predefinedboolean consistency check.
Similar to other entities, the sentinel value isfalse. Ensure domain logic is not expecting a defaulttruefor certain semantic domains.
105-110: Verify relationships involvingSnapshotId.
SnapshotIdhere is a key part of the foreign key to anObjectSnapshot. Confirm that theSetNullbehavior is correct for all domain scenarios.backend/FwLite/LcmCrdt/CompiledModels/ComplexFormTypeEntityType.cs (3)
93-102: Confirm foreign key uniqueness requirement.
The foreign key is declared withunique: trueanddeleteBehavior: DeleteBehavior.SetNull. Verify that a single principal entity can indeed handle multiple dependents if needed. Settinguniqueto true enforces one-to-one semantics, which might be correct for your use case, but confirm that it aligns with domain requirements.
104-114: Validate table naming and schema usage.
The entity is annotated to map to the table"ComplexFormType", with a null schema, which is standard for SQLite. Ensure consistency across the codebase if you rely on naming conventions or a specific schema approach for deployment.
20-91:❓ Verification inconclusive
Consider verifying usage of "jsonb" with SQLite.
Although specifying the store type as"jsonb"can be harmless in many SQLite setups, it is typically associated with PostgreSQL. Having a mismatched store type might be confusing or misleading to future maintainers. If you aim to support cross-database functionality or if there's a strict requirement for SQLite, consider clarifying or standardizing the type to"TEXT"(or a more appropriate SQLite-compatible type).If you want to validate the usage, you could run a quick check on the generated migrations or database schema:
🏁 Script executed:
#!/bin/bash # Show CREATE TABLE statements for ComplexFormType in SQLite # (Replace 'your_database_file.db' with your actual database file) sqlite3 your_database_file.db ".schema ComplexFormType"Length of output: 155
Verify the usage of "jsonb" for SQLite compatibility
The code inbackend/FwLite/LcmCrdt/CompiledModels/ComplexFormTypeEntityType.cs(lines 20–91) configures the"Name"property with a SQL store type"jsonb", which is typically associated with PostgreSQL. Our attempted validation via the SQLite command failed because thesqlite3utility was not available, so we couldn’t automatically verify that the generated schema is as expected in a SQLite environment.
- Please manually verify the schema (or run the migration) in an environment where
sqlite3is available to ensure that using"jsonb"is intentional and correctly handled.- If targeting SQLite exclusively (or aiming for cross-database functionality), consider using an appropriate SQLite type such as
"TEXT"or implementing a custom SQLite-compatible mapping for JSON data.backend/FwLite/LcmCrdt/Data/CompileModelCustomization.cs (2)
15-39: Thorough converter usage for IChange property.
You are correctly attaching a custom JSON converter for theChangeproperty, which is crucial for storing interface-based objects in relational columns. This approach looks robust. Just confirm that theJsonSerializerOptionsmodifications (lines 23–25) do not conflict with other parts of the system that might override or reuse the same options instance.
43-82: Verify references property element type mapping.
Setting the element type explicitly (line 80) enables EF Core to treatObjectSnapshot.Referencesas a primitive collection. This is helpful for your intended JSON storage. However, be sure it correctly handles any advanced scenarios, such as partial updates or concurrency checks on the array. Testing concurrency scenarios or partial updates might be beneficial.backend/FwLite/LcmCrdt/CompiledModels/WritingSystemEntityType.cs (2)
200-209: Ensure one-to-one relationship is intentional.
A foreign key withunique: trueimplies a one-to-one or one-to-zero/one relationship, andDeleteBehavior.SetNullensures proper orphaning behavior. Confirm that eachWritingSysteminstance having at most one parent entity matches your domain model intent.
211-221: Good use of partial method for customization.
Providing a partial methodCustomize(runtimeEntityType)invites flexible post-processing of EF Core mappings, thereby separating generated code from manual overrides. This is a sound approach for maintainability.backend/FwLite/LcmCrdt/CompiledModels/PublicationEntityType.cs (3)
104-114: No issues found
The table name, schema, and other relational annotations look consistent with the rest of the file.
93-102:❓ Verification inconclusive
Confirm desired foreign key uniqueness
You have marked the foreign key asunique: truewithDeleteBehavior.SetNull. This results in a one-to-one relationship. Confirm that this is intended and will handle all use cases properly.
🏁 Script executed:
#!/bin/bash # Verify usage of the SnapshotId foreign key in the codebase rg -A 5 "SnapshotId"Length of output: 65674
Confirm one-to-one FK relationship with SnapshotId is intended
The use ofunique: truecombined withDeleteBehavior.SetNullfor theSnapshotIdforeign key is consistently applied across several entity types (e.g., ComplexFormComponent, ExampleSentence, ComplexFormType, WritingSystem, and Publication) as verified in the codebase and accompanying tests. This confirms that the design enforces a one-to-one relationship between the dependent entity and the corresponding snapshot.Please confirm that this one-to-one relationship is indeed the desired behavior for all use cases before finalizing the changes.
20-90:❓ Verification inconclusive
Consider verifying 'jsonb' usage with SQLite
Although the property is annotated with"jsonb", SQLite does not natively support thejsonbtype as PostgreSQL does. If this is intentional or handled by a custom extension, please ensure proper runtime testing.
🏁 Script executed:
#!/bin/bash # Search for additional references to "jsonb" in the codebase rg -A 5 "jsonb"Length of output: 77284
Action Required: Confirm SQLite JSON Handling
The use of
"jsonb"is consistently applied throughout the repository—in migrations, model snapshots, and various entity type configurations (including inPublicationEntityType.cs). Although SQLite doesn’t natively support a PostgreSQL-stylejsonbtype, the code employs a custom mapping strategy (e.g., viaSqliteStringTypeMapping.Default.Clone, custom value converters, and JSON reader/writer implementations) to handle JSON serialization.Please confirm that:
- The custom mapping correctly emulates the intended behavior when running against SQLite.
- Adequate runtime tests are in place to ensure edge cases are covered.
backend/FwLite/LcmCrdt/CompiledModels/ChangeEntityEntityType.cs (2)
108-124: Cascade delete confirmation
The foreign key enforcesDeleteBehavior.Cascade. This may trigger extensive cascade deletions if a commit is removed. Confirm it aligns with the system’s desired logic.
126-136: No issues found
Table name and other relational annotations are consistent.backend/FwLite/LcmCrdt/CompiledModels/ExampleSentenceEntityType.cs (4)
21-163: Double check use of double and 'jsonb'
- Storing an
Orderasdoublecan introduce floating precision issues. Considerdecimalorintif precise ordering/sorting must be guaranteed.- The
jsonbcolumn type might not be recognized by SQLite unless a custom provider extension is in place—verify runtime behavior.
166-182: Cascade delete on Sense
Deleting a Sense will remove all associated ExampleSentences. This is typically desired if ExampleSentences only make sense in the context of their Sense.
184-193: Confirm unique foreign key usage
Enforcing aunique: trueforeign key onSnapshotIdwithDeleteBehavior.SetNullsuggests a one-to-one link. Ensure that your domain model requires this strict uniqueness.
195-205: No issues found
The table name and schema annotations are consistent with the rest of the file.backend/FwLite/LcmCrdt/CompiledModels/ObjectSnapshotEntityType.cs (2)
50-78: Confirm the feasibility of storingIObjectBasein JSON.
Storing complex objects directly in JSON can make querying or partial updates more cumbersome. Ensure that all current and future querying needs are met and that performance is acceptable when serializing/deserializing.
167-172: Verify uniqueness requirements for the composite index on (CommitId,EntityId).
Confirm that only oneObjectSnapshotcan match this combination. If multiple snapshots should share the same commit and entity, this uniqueness constraint may need revisiting.backend/FwLite/LcmCrdt/CompiledModels/EntryEntityType.cs (2)
70-98: Assess potential performance impacts of storingComplexFormTypesas JSON.
Large or frequently updated lists could degrade performance during serialization/deserialization and hamper complex queries.
240-243: Confirm whether the unique constraint onsnapshotIdaligns with your domain logic.
A unique index on a nullable property may limit usage if multiple entries could share the same snapshot reference.backend/FwLite/LcmCrdt/CompiledModels/CommitEntityType.cs (2)
54-82: EnsureCommitMetadataJSON usage meets functional and performance needs.
Storing metadata in JSON can reduce schema complexity but might complicate advanced filtering. Confirm coverage in tests and migrations.
99-171: Review theHybridDateTimecomplex property for accuracy and time zone handling.
TheValueConverter<DateTimeOffset, DateTime>sets the offset to UTC. Verify this won’t cause unexpected discrepancies when storing local times.backend/FwLite/LcmCrdt/CompiledModels/SenseEntityType.cs (5)
19-27: Entity registration appears correct.The
Create(...)method correctly registers theSenseentity and sets it as aRuntimeEntityTypefor EF Core. The usage ofmodel.AddEntityType("MiniLcm.Models.Sense", typeof(Sense))is consistent with standard EF Core entity registration practices.
146-175: Verify JSON column type for “SemanticDomains”.Similarly, the “SemanticDomains” property also uses
"jsonb". Ensure your SQLite environment (or any other provider) supports this column type or that the"jsonb"annotation is purely informational. If you do intend to run on PostgreSQL, this is fine, but otherwise confirm it won’t break in production.
199-242: Foreign key structure seems appropriate.The foreign keys reference other entities (
Entry,PartOfSpeech,Snapshot) with reasonable delete behaviors (CascadeorSetNull). Ensure that these behaviors match your domain requirements (e.g., whether you truly want to cascade deletions ofSensewhen you removeEntry).
256-256: Partial method usage.The
static partial void Customize(RuntimeEntityType runtimeEntityType);hook is a useful extension point. Verify that the corresponding partial implementation is present in another file (e.g.CompileModelCustomization.cs) so that any custom converters or logic is applied as intended.
38-68:✅ Verification successful
Potential mismatch using "jsonb" with SQLite.
The property “Definition” is assigned a relational column type of
"jsonb", which is typically a PostgreSQL-specific type. Since the type mapping referencesSqliteStringTypeMapping.Defaultand the file referencesMicrosoft.EntityFrameworkCore.Sqlite.Storage.Internal, confirm that the"jsonb"annotation and column type won’t cause issues on SQLite.Below is a script to verify the actual DDL or migrations for this property, ensuring the
"jsonb"type is recognized or mapped appropriately in SQLite:
🏁 Script executed:
#!/bin/bash # Description: Scan migrations or generated SQL for any mismatch with column type "jsonb" on SQLite. # Look for migration files or code referencing "Definition" or "jsonb" fd 'Migrations' --type d --max-depth 3 --exec rg 'Definition|jsonb'Length of output: 8229
Mapping Clarification & Resolution on "jsonb" Annotation for SQLite
After scanning the migrations, we see that several migration files (in the LexData area) intentionally use
"jsonb"as the column type. In theSenseEntityType.csfile, the property is mapped using the SQLite type mapping (viaSqliteStringTypeMapping.Default.Clone), and SQLite’s typeless nature means that the"jsonb"annotation will be treated as text without negative side effects. This confirms that the use of"jsonb"here is deliberate and should not cause issues on SQLite.To improve clarity, consider adding a brief comment in the code explaining that—even though
"jsonb"is PostgreSQL-specific—using the SQLite string type mapping ensures correct handling within SQLite.backend/FwLite/LcmCrdt/CompiledModels/ComplexFormComponentEntityType.cs (3)
19-25: Entity registration is consistent.The
Create(...)method properly registersComplexFormComponentas aRuntimeEntityType. The approach aligns with how EF Core sets up runtime models.
127-134: Multiple unique indexes on combined columns.You have two unique indexes:
(complexFormEntryId, componentEntryId)(complexFormEntryId, componentEntryId, componentSenseId)Confirm these indexing requirements don’t overlap or cause conflicts in scenarios where
componentSenseIdis null. Also verify that unique constraints with partial or null columns behave as intended on your database provider.
195-205: Ensure partialCustomizeimplementation exists.Like other compiled model files, this file calls
Customize(runtimeEntityType)at line 204. Verify that your partial method implementation in another file (e.g.CompileModelCustomization.cs) is present and that you handle any additional JSON serialization or property conversion logic forComplexFormComponentas needed.
…vate constructors
…y-specific json converters
hahn-kev
added
the
💻 FW Lite
closes #1603
in order to test this I enabled
PublishAoton the LCM debugger project and ran it. Unfortunatly Maui windows doesn't support AoT so I can't test it there. This should be tested on a mac to verify that it actually works.Lots of hacking around issues was required. I'm not sure I love a lot of this code right now but I want to get it here so we can test out if it works. In order to support AoT we needed to use an EF Compiled Model and Source generation for Json support.