Use typed_sql's snake_case naming override for SQL with Dart field names. (dart-lang#9451)

Author: isoos

app/lib/database/database.dart

@@ -162,7 +162,7 @@ class PrimaryDatabase {
 
     await migrateScripts(
       target: _adapter,
-      table: migrationDb.schema_migrations,
+      table: migrationDb.schemaMigrations,
       schemaName: 'pub-dev-primary',
       scripts: scripts,
     );
@@ -246,30 +246,29 @@ class PrimaryDatabase {
         'tasks':
             (await _db.tasks
                     .where(
-                      (task) =>
-                          task.runtime_version.equalsValue(runtimeVersion),
+                      (task) => task.runtimeVersion.equalsValue(runtimeVersion),
                     )
                     .orderBy((task) => [(task.finished, .descending)])
                     .limit(10)
                     .fetch())
                 .map((e) => [e.package, e.finished.toIso8601String()])
                 .toList(),
         'task_dependencies':
-            (await _db.task_dependencies
+            (await _db.taskDependencies
                     .where(
-                      (td) => td.runtime_version.equalsValue(runtimeVersion),
+                      (td) => td.runtimeVersion.equalsValue(runtimeVersion),
                     )
                     .limit(10)
                     .fetch())
                 .map((e) => [e.package, e.dependency])
                 .toList(),
-        'schema_migrations': (await migrationDb.schema_migrations.fetch())
+        'schema_migrations': (await migrationDb.schemaMigrations.fetch())
             .map(
               (e) => [
-                e.schema_name,
-                e.script_name,
-                e.script_sha256,
-                e.executed_at.toIso8601String(),
+                e.schemaName,
+                e.scriptName,
+                e.scriptSha256,
+                e.executedAt.toIso8601String(),
               ],
             )
             .toList(),

app/lib/database/migration.dart

@@ -5,33 +5,31 @@
 // NOTE: We want this tool to be part of the typed_sql package, do not depend
 //       on libraries that typed_sql itself wouldn't depend.
 
-// TODO(https://github.com/google/dart-neats/issues/347): remove this after typed_sql supports automatic snake_case convention
-// ignore_for_file: non_constant_identifier_names
-
 import 'dart:convert';
 
 import 'package:crypto/crypto.dart';
 import 'package:typed_sql/typed_sql.dart';
 
 part 'migration.g.dart';
 
+@SqlOverride.schema(naming: .snake_case)
 abstract final class SchemaMigrationSchema extends Schema {
-  Table<SchemaMigration> get schema_migrations;
+  Table<SchemaMigration> get schemaMigrations;
 }
 
-@PrimaryKey(['schema_name', 'script_name'])
+@PrimaryKey(['schemaName', 'scriptName'])
 abstract final class SchemaMigration extends Row {
   /// The name of the schema (major group, e.g. `main`, `accounts`...).
-  String get schema_name;
+  String get schemaName;
 
   /// The name of the script.
-  String get script_name;
+  String get scriptName;
 
   /// The SHA-256 of the script at the time of execution.
-  String get script_sha256;
+  String get scriptSha256;
 
   /// The timestamp of the execution.
-  DateTime get executed_at;
+  DateTime get executedAt;
 }
 
 /// Executes migrations [scripts] in alphabetical order into
@@ -47,7 +45,7 @@ Future<void> migrateScripts({
 
   // sanity check on the table, no update attempts
   final existingRows = await table
-      .where((m) => m.schema_name.equalsValue(schemaName))
+      .where((m) => m.schemaName.equalsValue(schemaName))
       .fetch();
 
   final hashes = <String, String>{};
@@ -64,27 +62,27 @@ Future<void> migrateScripts({
 
     // check existing row
     final existingRow = existingRows
-        .where((r) => r.script_name == script.name)
+        .where((r) => r.scriptName == script.name)
         .firstOrNull;
-    if (existingRow != null && existingRow.script_sha256 != hash) {
+    if (existingRow != null && existingRow.scriptSha256 != hash) {
       throw ArgumentError('Script hash difference detected: `${script.name}`.');
     }
   }
 
   // early exit if everything matches
   if (scripts.length == existingRows.length &&
-      existingRows.every((row) => hashes.containsKey(row.script_name))) {
+      existingRows.every((row) => hashes.containsKey(row.scriptName))) {
     return;
   }
 
   // check if all the rows have corresponding scripts
   final rowsWithoutScript = existingRows
-      .where((row) => !hashes.containsKey(row.script_name))
+      .where((row) => !hashes.containsKey(row.scriptName))
       .toList();
   if (rowsWithoutScript.isNotEmpty) {
     throw ArgumentError(
       'Existing history without local files (${rowsWithoutScript.length} items): '
-      '${rowsWithoutScript.take(5).map((row) => '`${row.script_name}`').join(', ')}',
+      '${rowsWithoutScript.take(5).map((row) => '`${row.scriptName}`').join(', ')}',
     );
   }
 
@@ -97,26 +95,24 @@ Future<void> migrateScripts({
       // QUESTION: can we scope this with schema prefix so that it is part of the same transaction?
       final unexpectedRows = await table
           .where((m) {
-            final mn = m.schema_name.equalsValue(schemaName);
+            final mn = m.schemaName.equalsValue(schemaName);
             if (i == 0) {
               return mn;
             }
-            return mn.and(
-              m.script_name.greaterThan(scripts[i - 1].name.asExpr),
-            );
+            return mn.and(m.scriptName.greaterThan(scripts[i - 1].name.asExpr));
           })
-          .orderBy((m) => [(m.script_name, Order.ascending)])
+          .orderBy((m) => [(m.scriptName, Order.ascending)])
           .fetch();
 
       if (unexpectedRows.isNotEmpty) {
         final first = unexpectedRows.first;
         // check race + idempotency, continue migrations with the next script if matching
-        if (first.script_name == script.name && first.script_sha256 == hash) {
+        if (first.scriptName == script.name && first.scriptSha256 == hash) {
           return;
         }
         // otherwise abort migrations
         throw ArgumentError(
-          'Incompatible existing history: `${first.script_name}` preceeds `${script.name}`.',
+          'Incompatible existing history: `${first.scriptName}` preceeds `${script.name}`.',
         );
       }
 
@@ -126,10 +122,10 @@ Future<void> migrateScripts({
       // QUESTION: can we scope this with schema prefix so that it is part of the same transaction?
       await table
           .insert(
-            schema_name: schemaName.asExpr,
-            script_name: script.name.asExpr,
-            script_sha256: hash.asExpr,
-            executed_at: Expr.currentTimestamp,
+            schemaName: schemaName.asExpr,
+            scriptName: script.name.asExpr,
+            scriptSha256: hash.asExpr,
+            executedAt: Expr.currentTimestamp,
           )
           .execute();
     });