chore(flutter): improve dart and flutter pub.dev scores

src/SDK/Language/Dart.php

@@ -372,6 +372,11 @@ public function getFiles(): array
                 'destination'   => '/pubspec.yaml',
                 'template'      => 'dart/pubspec.yaml.twig',
             ],
+            [
+                'scope'         => 'default',
+                'destination'   => '/analysis_options.yaml',
+                'template'      => 'dart/analysis_options.yaml.twig',
+            ],
             [
                 'scope'         => 'default',
                 'destination'   => '/lib/client_io.dart',

src/SDK/Language/Flutter.php

@@ -240,6 +240,11 @@ public function getFiles(): array
                 'destination'   => '/pubspec.yaml',
                 'template'      => 'flutter/pubspec.yaml.twig',
             ],
+            [
+                'scope'         => 'default',
+                'destination'   => '/analysis_options.yaml',
+                'template'      => 'flutter/analysis_options.yaml.twig',
+            ],
             [
                 'scope'         => 'service',
                 'destination'   => '/lib/services/{{service.name | caseDash}}.dart',

templates/dart/analysis_options.yaml.twig

@@ -0,0 +1 @@
+include: package:lints/recommended.yaml

templates/dart/lib/src/enums.dart.twig

@@ -16,6 +16,6 @@ enum ResponseType {
   /// Transform the response data to a String encoded with UTF8.
   plain,
 
-  /// Get original bytes, the type of response will be List<int>
+  /// Get original bytes, the type of response will be `List<int>`
   bytes
 }

templates/dart/lib/src/enums/enum.dart.twig

@@ -3,7 +3,7 @@ part of '../../enums.dart';
 enum {{ enum.name | caseUcfirst | overrideIdentifier }} {
     {%~ for value in enum.enum %}
     {%~ set key = enum.keys is empty ? value : enum.keys[loop.index0] %}
-    {{ key | caseEnumKey }}(value: '{{ value }}'){% if not loop.last %},{% else %};{% endif %}
+    {{ key | caseEnumKey | escapeKeyword }}(value: '{{ value }}'){% if not loop.last %},{% else %};{% endif %}
 
     {%~ endfor %}
 

templates/dart/pubspec.yaml.twig

@@ -11,6 +11,6 @@ dependencies:
   http: '>=0.13.6 <2.0.0'
 
 dev_dependencies:
-  lints: ^4.0.0
+  lints: ^6.0.0
   test: ^1.25.8
   mockito: ^5.4.4

templates/dart/test/query_test.dart.twig

@@ -1,14 +1,16 @@
+import 'dart:convert';
+
 import 'package:{{ language.params.packageName }}/{{ language.params.packageName }}.dart';
 {% if 'dart' in language.params.packageName %}
 import 'package:test/test.dart';
 {% else %}
 import 'package:flutter_test/flutter_test.dart';
 {% endif %}
 
-class BasicFilterQueryTest {
+class BasicFilterQueryTest<T> {
   final String description;
-  final dynamic value;
-  final String expectedValues;
+  final T value;
+  final List<T> expectedValues;
 
   BasicFilterQueryTest({
     required this.description,
@@ -23,7 +25,7 @@ void main() {
       BasicFilterQueryTest(
         description: 'with a string',
         value: 's',
-        expectedValues: ["s"],
+        expectedValues: ['s'],
       ),
       BasicFilterQueryTest(
         description: 'with an integer',
@@ -48,14 +50,14 @@ void main() {
       BasicFilterQueryTest(
         description: 'with a list',
         value: ['a', 'b', 'c'],
-        expectedValues: ["a","b","c"],
+        expectedValues: ['a', 'b', 'c'],
       ),
     ];
 
     group('equal()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.equal('attr', t.value).toJson();
+          final query = jsonDecode(Query.equal('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'equal');
@@ -66,7 +68,7 @@ void main() {
     group('notEqual()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.notEqual('attr', t.value).toJson();
+          final query = jsonDecode(Query.notEqual('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'notEqual');
@@ -77,7 +79,7 @@ void main() {
     group('lessThan()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.lessThan('attr', t.value).toJson();
+          final query = jsonDecode(Query.lessThan('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'lessThan');
@@ -88,7 +90,7 @@ void main() {
     group('lessThanEqual()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.lessThanEqual('attr', t.value).toJson();
+          final query = jsonDecode(Query.lessThanEqual('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'lessThanEqual');
@@ -99,7 +101,7 @@ void main() {
     group('greaterThan()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.greaterThan('attr', t.value).toJson();
+          final query = jsonDecode(Query.greaterThan('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'greaterThan');
@@ -110,7 +112,7 @@ void main() {
     group('greaterThanEqual()', () {
       for (var t in tests) {
         test(t.description, () {
-          final query = Query.greaterThanEqual('attr', t.value).toJson();
+          final query = jsonDecode(Query.greaterThanEqual('attr', t.value));
           expect(query['attribute'], 'attr');
           expect(query['values'], t.expectedValues);
           expect(query['method'], 'greaterThanEqual');
@@ -120,172 +122,172 @@ void main() {
   });
 
   test('returns search', () {
-    final query = Query.search('attr', 'keyword1 keyword2').toJson();
+    final query = jsonDecode(Query.search('attr', 'keyword1 keyword2'));
     expect(query['attribute'], 'attr');
     expect(query['values'], ['keyword1 keyword2']);
     expect(query['method'], 'search');
   });
 
   test('returns isNull', () {
-    final query = Query.isNull('attr').toJson();
+    final query = jsonDecode(Query.isNull('attr'));
     expect(query['attribute'], 'attr');
     expect(query['values'], null);
     expect(query['method'], 'isNull');
   });
 
   test('returns isNotNull', () {
-    final query = Query.isNotNull('attr', 'keyword1 keyword2').toJson();
+    final query = jsonDecode(Query.isNotNull('attr'));
     expect(query['attribute'], 'attr');
     expect(query['values'], null);
     expect(query['method'], 'isNotNull');
   });
 
   group('between()', () {
     test('with integers', () {
-      final query = Query.between('attr', 1, 2).toJson();
+      final query = jsonDecode(Query.between('attr', 1, 2));
       expect(query['attribute'], 'attr');
       expect(query['values'], [1, 2]);
       expect(query['method'], 'between');
     });
 
     test('with doubles', () {
-      final query = Query.between('attr', 1.0, 2.0).toJson();
+      final query = jsonDecode(Query.between('attr', 1.0, 2.0));
       expect(query['attribute'], 'attr');
       expect(query['values'], [1.0, 2.0]);
       expect(query['method'], 'between');
     });
 
     test('with strings', () {
-      final query = Query.between('attr', 'a', 'z').toJson();
+      final query = jsonDecode(Query.between('attr', 'a', 'z'));
       expect(query['attribute'], 'attr');
       expect(query['values'], ['a', 'z']);
       expect(query['method'], 'between');
     });
   });
 
   test('returns select', () {
-    final query = Query.select(['attr1', 'attr2']).toJson();
+    final query = jsonDecode(Query.select(['attr1', 'attr2']));
     expect(query['attribute'], null);
     expect(query['values'], ['attr1', 'attr2']);
     expect(query['method'], 'select');
   });
 
   test('returns orderAsc', () {
-    final query = Query.orderAsc('attr').toJson();
+    final query = jsonDecode(Query.orderAsc('attr'));
     expect(query['attribute'], 'attr');
     expect(query['values'], null);
     expect(query['method'], 'orderAsc');
   });
 
   test('returns orderDesc', () {
-    final query = Query.orderDesc('attr').toJson();
+    final query = jsonDecode(Query.orderDesc('attr'));
     expect(query['attribute'], 'attr');
     expect(query['values'], null);
     expect(query['method'], 'orderDesc');
   });
 
   test('returns cursorBefore', () {
-    final query = Query.cursorBefore('custom').toJson();
+    final query = jsonDecode(Query.cursorBefore('custom'));
     expect(query['attribute'], null);
     expect(query['values'], 'custom');
     expect(query['method'], 'cursorBefore');
   });
 
   test('returns cursorAfter', () {
-    final query = Query.cursorAfter('custom').toJson();
+    final query = jsonDecode(Query.cursorAfter('custom'));
     expect(query['attribute'], null);
     expect(query['values'], 'custom');
     expect(query['method'], 'cursorAfter');
   });
 
   test('returns limit', () {
-    final query = Query.limit(1).toJson();
+    final query = jsonDecode(Query.limit(1));
     expect(query['attribute'], null);
     expect(query['values'], 1);
     expect(query['method'], 'limit');
   });
 
   test('returns offset', () {
-    final query = Query.offset(1).toJson();
+    final query = jsonDecode(Query.offset(1));
     expect(query['attribute'], null);
     expect(query['values'], 1);
     expect(query['method'], 'offset');
   });
 
   test('returns notContains', () {
-    final query = Query.notContains('attr', 'value').toJson();
+    final query = jsonDecode(Query.notContains('attr', 'value'));
     expect(query['attribute'], 'attr');
     expect(query['values'], ['value']);
     expect(query['method'], 'notContains');
   });
 
   test('returns notSearch', () {
-    final query = Query.notSearch('attr', 'keyword1 keyword2').toJson();
+    final query = jsonDecode(Query.notSearch('attr', 'keyword1 keyword2'));
     expect(query['attribute'], 'attr');
     expect(query['values'], ['keyword1 keyword2']);
     expect(query['method'], 'notSearch');
   });
 
   group('notBetween()', () {
     test('with integers', () {
-      final query = Query.notBetween('attr', 1, 2).toJson();
+      final query = jsonDecode(Query.notBetween('attr', 1, 2));
       expect(query['attribute'], 'attr');
       expect(query['values'], [1, 2]);
       expect(query['method'], 'notBetween');
     });
 
     test('with doubles', () {
-      final query = Query.notBetween('attr', 1.0, 2.0).toJson();
+      final query = jsonDecode(Query.notBetween('attr', 1.0, 2.0));
       expect(query['attribute'], 'attr');
       expect(query['values'], [1.0, 2.0]);
       expect(query['method'], 'notBetween');
     });
 
     test('with strings', () {
-      final query = Query.notBetween('attr', 'a', 'z').toJson();
+      final query = jsonDecode(Query.notBetween('attr', 'a', 'z'));
       expect(query['attribute'], 'attr');
       expect(query['values'], ['a', 'z']);
       expect(query['method'], 'notBetween');
     });
   });
 
   test('returns notStartsWith', () {
-    final query = Query.notStartsWith('attr', 'prefix').toJson();
+    final query = jsonDecode(Query.notStartsWith('attr', 'prefix'));
     expect(query['attribute'], 'attr');
     expect(query['values'], ['prefix']);
     expect(query['method'], 'notStartsWith');
   });
 
   test('returns notEndsWith', () {
-    final query = Query.notEndsWith('attr', 'suffix').toJson();
+    final query = jsonDecode(Query.notEndsWith('attr', 'suffix'));
     expect(query['attribute'], 'attr');
     expect(query['values'], ['suffix']);
     expect(query['method'], 'notEndsWith');
   });
 
   test('returns createdBefore', () {
-    final query = Query.createdBefore('2023-01-01').toJson();
+    final query = jsonDecode(Query.createdBefore('2023-01-01'));
     expect(query['attribute'], null);
     expect(query['values'], '2023-01-01');
     expect(query['method'], 'createdBefore');
   });
 
   test('returns createdAfter', () {
-    final query = Query.createdAfter('2023-01-01').toJson();
+    final query = jsonDecode(Query.createdAfter('2023-01-01'));
     expect(query['attribute'], null);
     expect(query['values'], '2023-01-01');
     expect(query['method'], 'createdAfter');
   });
 
   test('returns updatedBefore', () {
-    final query = Query.updatedBefore('2023-01-01').toJson();
+    final query = jsonDecode(Query.updatedBefore('2023-01-01'));
     expect(query['attribute'], null);
     expect(query['values'], '2023-01-01');
     expect(query['method'], 'updatedBefore');
   });
 
   test('returns updatedAfter', () {
-    final query = Query.updatedAfter('2023-01-01').toJson();
+    final query = jsonDecode(Query.updatedAfter('2023-01-01'));
     expect(query['attribute'], null);
     expect(query['values'], '2023-01-01');
     expect(query['method'], 'updatedAfter');

templates/dart/test/src/enums_test.dart.twig

@@ -8,9 +8,11 @@ import 'package:flutter_test/flutter_test.dart';
 void main() {
   group('name()', () {
     for (final method in HttpMethod.values) {
-      test('returns ${method.toString().split('.').last.toUpperCase()} for $method', () {
+      test(
+          'returns ${method.toString().split('.').last.toUpperCase()} for $method',
+          () {
         expect(method.name(), method.toString().split('.').last.toUpperCase());
       });
     }
   });
-}
+}

templates/dart/test/src/exception_test.dart.twig

@@ -12,10 +12,13 @@ void main() {
       expect(exception1.toString(), equals('{{spec.title | caseUcfirst}}Exception'));
 
       final exception2 = {{spec.title | caseUcfirst}}Exception('Some error message');
-      expect(exception2.toString(), equals('{{spec.title | caseUcfirst}}Exception: , Some error message (0)'));
+      expect(exception2.toString(),
+          equals('AppwriteException: , Some error message (0)'));
 
-      final exception3 = {{spec.title | caseUcfirst}}Exception('Invalid request', 400, 'ValidationError');
-      expect(exception3.toString(), equals('{{spec.title | caseUcfirst}}Exception: ValidationError, Invalid request (400)'));
+      final exception3 =
+          AppwriteException('Invalid request', 400, 'ValidationError');
+      expect(exception3.toString(),
+          equals('AppwriteException: ValidationError, Invalid request (400)'));
     });
   });
 }

templates/dart/test/src/input_file_test.dart.twig

@@ -40,7 +40,8 @@ void main() {
     });
 
     test('creates InputFile from bytes', () {
-      final inputFile = InputFile.fromBytes(bytes: [1, 2, 3], filename: 'file.txt');
+      final inputFile =
+          InputFile.fromBytes(bytes: [1, 2, 3], filename: 'file.txt');
 
       expect(inputFile.path, isNull);
       expect(inputFile.filename, 'file.txt');

templates/dart/test/src/models/model_test.dart.twig

@@ -8,7 +8,6 @@ import 'package:flutter_test/flutter_test.dart';
 
 void main() {
   group('{{ definition.name | caseUcfirst | overrideIdentifier }}', () {
-
     test('model', () {
       final model = {{ definition.name | caseUcfirst | overrideIdentifier }}(
 {% for property in definition.properties | filter(p => p.required) %}

templates/dart/test/src/response_test.dart.twig

@@ -19,4 +19,4 @@ void main() {
       expect(response.toString(), '{"x":1}');
     });
   });
-}
+}

templates/flutter/analysis_options.yaml.twig

@@ -0,0 +1 @@
+include: package:flutter_lints/flutter.yaml