@@ -1,3 +1,9 @@
+# 6.3.0
+
+## Changes
+
+- `SchemaBuilderOptions.IgnoreProps` is empty by default. It held `Database`, `Model`, `ChangeTracker` and `ContextId` to keep an EF Core `DbContext`'s own members out of the schema, but it matches by name on every type, so a property called `Model` (a car's, a run's, a usage row's) was silently left out wherever it appeared. Those `DbContext` members are now left out by the type that declares them - `Microsoft.EntityFrameworkCore.DbContext`, matched by name so there is still no EF reference - and a property with one of those names on any other type is a field. A schema with such a property gains that field; to keep it out, `options.Builder.IgnoreProps.Add("Model")` (or `[GraphQLIgnore]` on the property).
+
 # 6.2.4
 
 ## Fixes
 
@@ -166,7 +166,7 @@ public List<AllowedException> AllowedExceptions { get; set; } = [
    - `.AutoCreateEnumTypes` - automatically create Enum types in the schema if found in the `DemoContext` object graph. Default is `true`
    - `.AutoCreateNewComplexTypes` - automatically add dotnet types found in the object graph to the schema. This will also call `AddAllFields()` on those types passing this options object to it. Default is `true`
    - `.AutoCreateInterfaceTypes` - If true (default = false), any object type that is encountered during reflection of the object graph that has abstract or interface types (regardless of if they are referenced by other fields), those will be added to the schema as an Interface including it's fields. Note types are always linked (`implements`) to base types that are in the schema as interfaces (e.g. an abstract base class referenced by a context property) - this option only controls _creating_ interface types for base types not otherwise in the schema
-   - `.IgnoreProps` - List properties or field names to ignore. Default includes a list of EF properties. Default list includes
+   - `.IgnoreProps` - Property or field names to ignore on every type. Empty by default. An Entity Framework Core `DbContext`'s own members are always left out (below), by the type that declares them rather than by name, so a property with one of those names on your own types is still a field. The `DbContext` members left out are
 
    ```json
     "Database",
 
@@ -438,9 +438,16 @@ public static List<BaseField> GetFieldsFromObject(Type type, ISchemaType fromTyp
         return field;
     }
 
+    /// <summary>
+    /// EF Core's own DbContext members - Database, Model, ChangeTracker, ContextId - are its machinery,
+    /// not data. Matched by where they are declared, so a property of the same name on an entity is
+    /// still a field, and by type name, so EntityGraphQL needs no reference to EF.
+    /// </summary>
+    private static bool IsDeclaredOnDbContext(MemberInfo member) => member.DeclaringType?.FullName == "Microsoft.EntityFrameworkCore.DbContext";
+
     private static bool ShouldIncludeMember(MemberInfo prop, SchemaBuilderOptions options, bool isInputType)
     {
-        if (options.IgnoreProps.Contains(prop.Name) || GraphQLIgnoreAttribute.ShouldIgnoreMemberFromQuery(prop))
+        if (IsDeclaredOnDbContext(prop) || options.IgnoreProps.Contains(prop.Name) || GraphQLIgnoreAttribute.ShouldIgnoreMemberFromQuery(prop))
             return false;
 
         if (isInputType && GraphQLIgnoreAttribute.ShouldIgnoreMemberFromInput(prop))
 
@@ -11,9 +11,13 @@ namespace EntityGraphQL.Schema;
 public class SchemaBuilderOptions
 {
     /// <summary>
-    /// List properties or field names to ignore. Default includes a list of EF properties
+    /// Property or field names to ignore, on every type. Empty by default.
+    ///
+    /// The members of an Entity Framework Core DbContext (Database, Model, ChangeTracker, ContextId) are
+    /// always left out, by the type that declares them rather than by name, so an entity's own property
+    /// with one of those names is kept. Add a name here to leave it out everywhere.
     /// </summary>
-    public HashSet<string> IgnoreProps { get; set; } = ["Database", "Model", "ChangeTracker", "ContextId"];
+    public HashSet<string> IgnoreProps { get; set; } = [];
 
     /// <summary>
     /// List of dotnet Types to ignore when adding types to the schema
 
@@ -0,0 +1,17 @@
+using EntityGraphQL.Schema;
+using Xunit;
+
+namespace EntityGraphQL.EF.Tests;
+
+public class DbContextMembersTests
+{
+    [Fact]
+    public void TestDbContextOwnMembersAreNotFields()
+    {
+        var schema = SchemaBuilder.FromObject<TestDbContext>();
+
+        foreach (var name in new[] { "database", "model", "changeTracker", "contextId" })
+            Assert.False(schema.Query().HasField(name, null), $"{name} should not be in the schema");
+        Assert.True(schema.Query().HasField("movies", null));
+    }
+}
@@ -593,4 +593,35 @@ private class Property : IUnion
     {
         public Guid Id { get; set; }
     }
+
+    [Fact]
+    public void TestPropertyNamedLikeADbContextMemberIsAField()
+    {
+        // The names IgnoreProps used to hold by default left these out of every type, not just the DbContext
+        var schema = SchemaBuilder.FromObject<VehicleContext>();
+
+        Assert.True(schema.Type<Vehicle>().HasField("model", null));
+        Assert.True(schema.Type<Vehicle>().HasField("database", null));
+    }
+
+    [Fact]
+    public void TestIgnorePropsStillIgnoresByName()
+    {
+        var schema = SchemaBuilder.FromObject<VehicleContext>(new SchemaBuilderOptions { IgnoreProps = ["Model"] });
+
+        Assert.False(schema.Type<Vehicle>().HasField("model", null));
+        Assert.True(schema.Type<Vehicle>().HasField("database", null));
+    }
+
+    private class VehicleContext
+    {
+        public List<Vehicle> Vehicles { get; set; } = [];
+    }
+
+    private class Vehicle
+    {
+        public int Id { get; set; }
+        public string Model { get; set; } = "";
+        public string Database { get; set; } = "";
+    }
 }