Remove FilterRelation.In / "property IN" queries, upgrade googleapis{,_beta} dependencies

lib/src/db/annotations.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of gcloud.db;
 
 /// Annotation used to mark dart classes which can be stored into datastore.
 ///
 /// The `Kind` annotation on a class as well as other `Property` annotations on
 /// fields or getters of the class itself (and any of it's superclasses) up to
@@ skipping 70 matching lines @@
   /// `true`.
   final bool indexed;
 
   const Property({this.propertyName, this.required: false, this.indexed: true});
 
   bool validate(ModelDB db, Object value) {
     if (required && value == null) return false;
     return true;
   }
 
-  Object encodeValue(ModelDB db, Object value);
+  Object encodeValue(ModelDB db, Object value, {bool forComparison: false});
 
   Object decodePrimitiveValue(ModelDB db, Object value);
 }
 
 /// An abstract base class for primitive properties which can e.g. be used
 /// within a composed `ListProperty`.
 abstract class PrimitiveProperty extends Property {
   const PrimitiveProperty(
       {String propertyName, bool required: false, bool indexed: true})
       : super(propertyName: propertyName, required: required, indexed: indexed);
 
-  Object encodeValue(ModelDB db, Object value) => value;
+  Object encodeValue(ModelDB db, Object value, {bool forComparison: false}) => value;
 
   Object decodePrimitiveValue(ModelDB db, Object value) => value;
 }
 
 /// A boolean [Property].
 ///
 /// It will validate that values are booleans before writing them to the
 /// datastore and when reading them back.
 class BoolProperty extends PrimitiveProperty {
   const BoolProperty(
@@ skipping 48 matching lines @@
 /// It will validate that values are keys before writing them to the
 /// datastore and when reading them back.
 class ModelKeyProperty extends PrimitiveProperty {
   const ModelKeyProperty(
       {String propertyName, bool required: false, bool indexed: true})
       : super(propertyName: propertyName, required: required, indexed: indexed);
 
   bool validate(ModelDB db, Object value)
       => super.validate(db, value) && (value == null || value is Key);
 
-  Object encodeValue(ModelDB db, Object value) {
+  Object encodeValue(ModelDB db, Object value, {bool forComparison: false}) {
     if (value == null) return null;
     return db.toDatastoreKey(value);
   }
 
   Object decodePrimitiveValue(ModelDB db, Object value) {
     if (value == null) return null;
     return db.fromDatastoreKey(value as datastore.Key);
   }
 }
 
 /// A binary blob [Property].
 ///
 /// It will validate that values are blobs before writing them to the
 /// datastore and when reading them back. Blob values will be represented by
 /// List<int>.
 class BlobProperty extends PrimitiveProperty {
   const BlobProperty({String propertyName, bool required: false})
      : super(propertyName: propertyName, required: required, indexed: false);
 
   // NOTE: We don't validate that the entries of the list are really integers
   // of the range 0..255!
   // If an untyped list was created the type check will always succeed. i.e.
   //   "[1, true, 'bar'] is List<int>" evaluates to `true`
   bool validate(ModelDB db, Object value)
       => super.validate(db, value) && (value == null || value is List<int>);
 
-  Object encodeValue(ModelDB db, Object value) {
+  Object encodeValue(ModelDB db, Object value, {bool forComparison: false}) {
       if (value == null) return null;
       return new datastore.BlobValue(value);
   }
 
   Object decodePrimitiveValue(ModelDB db, Object value) {
     if (value == null) return null;
 
     datastore.BlobValue blobValue = value;
     return blobValue.bytes;
   }
@@ skipping 37 matching lines @@
 
   bool validate(ModelDB db, Object value) {
     if (!super.validate(db, value) || value is! List) return false;
 
     for (var entry in value) {
        if (!subProperty.validate(db, entry)) return false;
     }
     return true;
   }
 
-  Object encodeValue(ModelDB db, Object value) {
+  Object encodeValue(ModelDB db, Object value, {bool forComparison: false}) {
+    if (forComparison) {
+      // If we have comparison of list properties (i.e. repeated property names)
+      // the comparison object must not be a list, but the value itself.
+      // i.e.
+      //
+      //   class Article {
+      //      ...
+      //      @ListProperty(StringProperty())
+      //      List<String> tags;
+      //      ...
+      //   }
+      //
+      // should be queried via
+      //
+      //   await db.query(Article, 'tags=', "Dart").toList();
+      //
+      // So the [value] for the comparison is of type `String` and not
+      // `List<String>`!
+      return subProperty.encodeValue(db, value, forComparison: true);
+    }
+
     if (value == null) return null;
     List list = value;
     if (list.length == 0) return null;
     if (list.length == 1) return subProperty.encodeValue(db, list[0]);
     return list.map(
         (value) => subProperty.encodeValue(db, value)).toList();
   }
 
   Object decodePrimitiveValue(ModelDB db, Object value) {
     if (value == null) return [];
     if (value is! List) return [subProperty.decodePrimitiveValue(db, value)];
     return (value as List)
         .map((entry) => subProperty.decodePrimitiveValue(db, entry))
         .toList();
   }
 }
 
 /// A convenience [Property] for list of strings.
 class StringListProperty extends ListProperty {
   const StringListProperty({String propertyName, bool indexed: true})
       : super(const StringProperty(),
               propertyName: propertyName, indexed: indexed);
 }