Schema validation: Allow ignoring column constraints

Closes #3575

Author: simolus3

drift_dev/CHANGELOG.md

@@ -1,7 +1,8 @@
-## 2.26.2-dev
+## 2.27.0-dev
 
 - Fix generating versioned schema code for columns referencing other columns in
   `generatedAs` expressions.
+- Schema validation: Allow ignoring column constraints.
 
 ## 2.26.1
 

drift_dev/lib/api/migrations_common.dart

@@ -54,11 +54,17 @@ abstract class SchemaVerifier<DB extends CommonDatabase> {
   /// the database into the expected schema. If the comparison fails, a
   /// [SchemaMismatch] exception will be thrown.
   ///
-  /// If [validateDropped] is enabled (defaults to `false`), the method also
-  /// validates that no further tables, triggers or views apart from those
-  /// expected exist.
-  Future<void> migrateAndValidate(GeneratedDatabase db, int expectedVersion,
-      {bool validateDropped = false});
+  /// The [ValidationOptions] can be used to make the schema validation more
+  /// strict (e.g. by enabling [ValidationOptions.validateDropped] to ensure
+  /// that no old tables continue to exist if they're not referenced in the new
+  /// schema) or more lenient (e.g. by disabling
+  /// [ValidationOptions.validateColumnConstraints]).
+  Future<void> migrateAndValidate(
+    GeneratedDatabase db,
+    int expectedVersion, {
+    ValidationOptions options = const ValidationOptions(),
+    @Deprecated('Use field in ValidationOptions instead') bool? validateDropped,
+  });
 
   /// Utility function used by generated tests to verify that migrations
   /// modify the database schema as expected.
@@ -156,3 +162,36 @@ class InitializedSchema<DB extends CommonDatabase> {
   /// forgetting to call [close] does not have terrible side-effects.
   void close() => rawDatabase.dispose();
 }
+
+/// Options that control how schemas are compared to find mismatches.
+final class ValidationOptions {
+  /// When enabled (defaults to `false`), validate that no furhter tables,
+  /// triggers or views apart from those expected exist.
+  final bool validateDropped;
+
+  /// When enabled (defualts to `true`), validate column constraints.
+  ///
+  /// When disabled, schema verification passes even without
+  final bool validateColumnConstraints;
+
+  const ValidationOptions({
+    this.validateDropped = false,
+    this.validateColumnConstraints = true,
+  });
+
+  /// Returns new [ValidationOptions] with the [ValidationOptions.validateDropped]
+  /// field replaced if [validateDropped] is not null.validateDropped
+  ///
+  /// This is used for backwards-compatibility when [validateDropped] was the
+  /// only option and no [ValidationOptions] class existed.
+  ValidationOptions applyDeprecatedValidateDroppedParam(bool? validateDropped) {
+    if (validateDropped case final changed?) {
+      return ValidationOptions(
+        validateColumnConstraints: validateColumnConstraints,
+        validateDropped: changed,
+      );
+    } else {
+      return this;
+    }
+  }
+}

drift_dev/lib/api/migrations_native.dart

@@ -43,14 +43,23 @@ extension VerifySelf on GeneratedDatabase {
   /// database, (perhaps in a [MigrationStrategy.beforeOpen] callback) to verify
   /// that your database schema is what drift expects.
   ///
-  /// When [validateDropped] is enabled (it is by default), this method also
-  /// verifies that all schema elements that you've deleted at some point are no
-  /// longer present in your runtime schema.
+  /// The [common.ValidationOptions] can be used to make the schema validation
+  /// more strict (e.g. by enabling [common.ValidationOptions.validateDropped]
+  /// to ensure that no old tables continue to exist if they're not referenced
+  /// in the new schema) or more lenient (e.g. by disabling
+  /// [common.ValidationOptions.validateColumnConstraints]).
   ///
   /// This variant of [validateDatabaseSchema] is only supported on native
   /// platforms (Android, iOS, macOS, Linux and Windows).
-  Future<void> validateDatabaseSchema({bool validateDropped = true}) async {
-    await verifyDatabase(this, validateDropped, NativeDatabase.memory);
+  Future<void> validateDatabaseSchema({
+    common.ValidationOptions options = const common.ValidationOptions(),
+    @Deprecated('Use field in ValidationOptions instead') bool? validateDropped,
+  }) async {
+    await verifyDatabase(
+      this,
+      options.applyDeprecatedValidateDroppedParam(validateDropped),
+      NativeDatabase.memory,
+    );
   }
 }
 

drift_dev/lib/api/migrations_web.dart

@@ -45,17 +45,23 @@ extension VerifySelf on GeneratedDatabase {
   /// database, (perhaps in a [MigrationStrategy.beforeOpen] callback) to verify
   /// that your database schema is what drift expects.
   ///
-  /// When [validateDropped] is enabled (it is by default), this method also
-  /// verifies that all schema elements that you've deleted at some point are no
-  /// longer present in your runtime schema.
+  /// The [common.ValidationOptions] can be used to make the schema validation
+  /// more strict (e.g. by enabling [common.ValidationOptions.validateDropped]
+  /// to ensure that no old tables continue to exist if they're not referenced
+  /// in the new schema) or more lenient (e.g. by disabling
+  /// [common.ValidationOptions.validateColumnConstraints]).
   ///
-  /// This variant of [validateDatabaseSchema] is only supported on native
-  /// platforms (Android, iOS, macOS, Linux and Windows).
+  /// This variant of [validateDatabaseSchema] is only supported on the web as
+  /// a platform.
   Future<void> validateDatabaseSchema({
     required CommonSqlite3 sqlite3,
-    bool validateDropped = true,
+    common.ValidationOptions options = const common.ValidationOptions(),
+    @Deprecated('Use field in ValidationOptions instead') bool? validateDropped,
   }) async {
     await verifyDatabase(
-        this, validateDropped, () => WasmDatabase.inMemory(sqlite3));
+      this,
+      options.applyDeprecatedValidateDroppedParam(validateDropped),
+      () => WasmDatabase.inMemory(sqlite3),
+    );
   }
 }

drift_dev/lib/src/services/schema/find_differences.dart

@@ -2,6 +2,7 @@ import 'package:sqlparser/sqlparser.dart';
 // ignore: implementation_imports
 import 'package:sqlparser/src/utils/ast_equality.dart';
 
+import '../../../api/migrations_common.dart';
 import '../../analysis/drift_native_functions.dart';
 
 class Input {
@@ -21,9 +22,7 @@ class FindSchemaDifferences {
   /// The actual schema entities
   final List<Input> actualSchema;
 
-  /// When set, [actualSchema] may not contain more entities than
-  /// [referenceSchema].
-  final bool validateDropped;
+  final ValidationOptions options;
 
   final SqlEngine _engine = SqlEngine(
     EngineOptions(enabledExtensions: const [
@@ -33,16 +32,15 @@ class FindSchemaDifferences {
     ]),
   );
 
-  FindSchemaDifferences(
-      this.referenceSchema, this.actualSchema, this.validateDropped);
+  FindSchemaDifferences(this.referenceSchema, this.actualSchema, this.options);
 
   CompareResult compare() {
     return _compareNamed<Input>(
       reference: referenceSchema,
       actual: actualSchema,
       name: (e) => e.name,
       compare: _compareInput,
-      validateActualInReference: validateDropped,
+      validateActualInReference: options.validateDropped,
     );
   }
 
@@ -170,13 +168,15 @@ class FindSchemaDifferences {
           'Different types: Expected ${ref.typeName}, got ${act.typeName}');
     }
 
-    try {
-      enforceEqualIterable(ref.constraints, act.constraints);
-    } catch (e) {
-      final firstSpan = ref.constraints.spanOrNull?.text ?? '';
-      final secondSpan = act.constraints.spanOrNull?.text ?? '';
-      return FoundDifference(
-          'Not equal: `$firstSpan` (expected) and `$secondSpan` (actual)');
+    if (options.validateColumnConstraints) {
+      try {
+        enforceEqualIterable(ref.constraints, act.constraints);
+      } catch (e) {
+        final firstSpan = ref.constraints.spanOrNull?.text ?? '';
+        final secondSpan = act.constraints.spanOrNull?.text ?? '';
+        return FoundDifference(
+            'Not equal: `$firstSpan` (expected) and `$secondSpan` (actual)');
+      }
     }
 
     return const Success();

drift_dev/lib/src/services/schema/verifier_common.dart

@@ -20,10 +20,9 @@ bool isInternalElement(String name, List<String> virtualTables) {
 }
 
 void verify(List<Input> referenceSchema, List<Input> actualSchema,
-    bool validateDropped) {
+    ValidationOptions options) {
   final result =
-      FindSchemaDifferences(referenceSchema, actualSchema, validateDropped)
-          .compare();
+      FindSchemaDifferences(referenceSchema, actualSchema, options).compare();
 
   if (!result.noChanges) {
     throw SchemaMismatch(result.describe());
@@ -32,7 +31,7 @@ void verify(List<Input> referenceSchema, List<Input> actualSchema,
 
 Future<void> verifyDatabase(
   GeneratedDatabase db,
-  bool validateDropped,
+  ValidationOptions options,
   QueryExecutor Function() open,
 ) async {
   final virtualTables = db.allTables
@@ -57,7 +56,7 @@ Future<void> verifyDatabase(
     await referenceDb.close();
   }
 
-  verify(referenceSchema, schemaOfThisDatabase, validateDropped);
+  verify(referenceSchema, schemaOfThisDatabase, options);
 }
 
 /// Thrown when the actual schema differs from the expected schema.
@@ -87,8 +86,12 @@ abstract base class VerifierImplementation<DB extends CommonDatabase>
   QueryExecutor wrapOpened(DB db, {required bool closeUnderlyingOnClose});
 
   @override
-  Future<void> migrateAndValidate(GeneratedDatabase db, int expectedVersion,
-      {bool validateDropped = false}) async {
+  Future<void> migrateAndValidate(
+    GeneratedDatabase db,
+    int expectedVersion, {
+    ValidationOptions options = const ValidationOptions(),
+    bool? validateDropped,
+  }) async {
     final virtualTables = <String>[
       for (final table in db.allTables)
         if (table is VirtualTableInfo) table.entityName,
@@ -110,7 +113,11 @@ abstract base class VerifierImplementation<DB extends CommonDatabase>
     await db.executor.ensureOpen(_DelegatingUser(expectedVersion, db));
     final actualSchema = await db.executor.collectSchemaInput(virtualTables);
 
-    verify(referenceSchema, actualSchema, validateDropped);
+    verify(
+      referenceSchema,
+      actualSchema,
+      options.applyDeprecatedValidateDroppedParam(validateDropped),
+    );
   }
 
   DB _setupDatabase() {

drift_dev/test/services/schema/find_differences_test.dart

@@ -1,3 +1,4 @@
+import 'package:drift_dev/api/migrations_common.dart';
 import 'package:drift_dev/src/services/schema/find_differences.dart';
 import 'package:test/test.dart';
 
@@ -87,6 +88,16 @@ void main() {
               'Not equal: `PRIMARY KEY NOT NULL` (expected) and `` (actual)'),
         );
       });
+
+      test('ignored column constraints diff', () {
+        final result = compare(
+          Input('a', 'CREATE TABLE a (id INTEGER PRIMARY KEY NOT NULL);'),
+          Input('a', 'CREATE TABLE a (id INTEGER);'),
+          options: const ValidationOptions(validateColumnConstraints: false),
+        );
+
+        expect(result, hasNoChanges);
+      });
     });
 
     test('of different type', () {
@@ -104,8 +115,12 @@ void main() {
   });
 }
 
-CompareResult compare(Input a, Input b) {
-  return FindSchemaDifferences([a], [b], false).compare();
+CompareResult compare(
+  Input a,
+  Input b, {
+  ValidationOptions options = const ValidationOptions(),
+}) {
+  return FindSchemaDifferences([a], [b], options).compare();
 }
 
 Matcher hasChanges = _matchChanges(false);

extras/drift_devtools_extension/lib/src/schema_validator.dart

@@ -1,4 +1,5 @@
 import 'package:devtools_app_shared/ui.dart';
+import 'package:drift_dev/api/migrations_common.dart';
 // ignore: implementation_imports
 import 'package:drift_dev/src/services/schema/find_differences.dart';
 // ignore: implementation_imports
@@ -68,7 +69,7 @@ class SchemaVerifier extends AutoDisposeAsyncNotifier<SchemaStatus> {
       }
 
       try {
-        verify(expected, actual, true);
+        verify(expected, actual, const ValidationOptions());
         return SchemaComparisonResult(
           schemaValid: true,
           message: 'The schema of the database matches its Dart and .drift '