Multiple Updates

Author: gravy-jones-locker

.pre-commit-config.yaml

@@ -2,7 +2,7 @@ exclude: '^docs/conf.py'
 
 repos:
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.3.0
+  rev: v4.4.0
   hooks:
   - id: trailing-whitespace
   - id: check-added-large-files
@@ -28,18 +28,18 @@ repos:
 #       --remove-unused-variables,
 #     ]
 - repo: https://github.com/hadialqattan/pycln
-  rev: v2.1.1
+  rev: v2.1.3
   hooks:
     - id: pycln
       args: [--config=setup.cfg]
 
 - repo: https://github.com/pycqa/isort
-  rev: 5.10.1
+  rev: 5.12.0
   hooks:
   - id: isort
 
 - repo: https://github.com/psf/black
-  rev: 22.8.0
+  rev: 23.3.0
   hooks:
   - id: black
     language_version: python3
@@ -52,7 +52,7 @@ repos:
 #     additional_dependencies: [black]
 
 - repo: https://github.com/PyCQA/flake8
-  rev: 5.0.4
+  rev: 6.0.0
   hooks:
   - id: flake8
   ## You can add flake8 plugins via `additional_dependencies`:

src/strawberry_sqlalchemy_mapper/loader.py

@@ -39,7 +39,11 @@ async def load_fn(keys: List[Tuple]) -> List[Any]:
                 def group_by_remote_key(row: Any) -> Tuple:
                     return tuple(
                         [
-                            getattr(row, remote.key)
+                            [
+                                getattr(row, k)
+                                for k, column in row.__mapper__.c.items()
+                                if remote.key == column.key
+                            ][0]
                             for _, remote in relationship.local_remote_pairs
                         ]
                     )

src/strawberry_sqlalchemy_mapper/mapper.py

@@ -151,6 +151,8 @@ def __init__(
         extra_sqlalchemy_type_to_strawberry_type_map: Optional[
             Mapping[Type[TypeEngine], Type[Any]]
         ] = None,
+        edge_type: Type = None,
+        connection_type: Type = None,
     ) -> None:
         if model_to_type_name is None:
             model_to_type_name = self._default_model_to_type_name
@@ -172,6 +174,9 @@ def __init__(
         self._related_type_models = set()
         self._related_interface_models = set()
 
+        self.edge_type = edge_type
+        self.connection_type = connection_type
+
     @staticmethod
     def _default_model_to_type_name(model: Type[BaseModelType]) -> str:
         return model.__name__
@@ -211,6 +216,8 @@ def _edge_type_for(self, type_name: str) -> Type[Any]:
         Get or create a corresponding Edge model for the given type
         (to support future pagination)
         """
+        if self.edge_type is not None:
+            return self.edge_type
         edge_name = f"{type_name}Edge"
         if edge_name not in self.edge_types:
             self.edge_types[edge_name] = edge_type = strawberry.type(
@@ -229,6 +236,8 @@ def _connection_type_for(self, type_name: str) -> Type[Any]:
         Get or create a corresponding Connection model for the given type
         (to support future pagination)
         """
+        if self.connection_type is not None:
+            return self.connection_type[ForwardRef(type_name)]
         connection_name = f"{type_name}Connection"
         if connection_name not in self.connection_types:
             self.connection_types[connection_name] = connection_type = strawberry.type(
@@ -259,7 +268,7 @@ def _convert_column_to_strawberry_type(
         corresponding strawberry type.
         """
         if isinstance(column.type, Enum):
-            type_annotation = column.type.python_type
+            type_annotation = strawberry.enum(column.type.python_type)
         elif isinstance(column.type, ARRAY):
             item_type = self._convert_column_to_strawberry_type(
                 Column(column.type.item_type, nullable=False)
@@ -404,7 +413,11 @@ async def resolve(self, info: Info):
             else:
                 relationship_key = tuple(
                     [
-                        getattr(self, local.key)
+                        [
+                            getattr(self, k)
+                            for k, column in self.__mapper__.c.items()
+                            if local.key == column.key
+                        ][0]
                         for local, _ in relationship.local_remote_pairs
                     ]
                 )
@@ -539,6 +552,7 @@ def type(
         model: Type[BaseModelType],
         make_interface=False,
         use_federation=False,
+        **kwargs,
     ) -> Callable[[Type[object]], Any]:
         """
         Decorate a type with this to register it as a strawberry type
@@ -560,128 +574,158 @@ class Employee:
         ```
         """
 
-        def convert(type_: Any) -> Any:
-            old_annotations = getattr(type_, "__annotations__", {})
-            type_.__annotations__ = {}
-            mapper: Mapper = inspect(model)
-            generated_field_keys = []
-
-            excluded_keys = getattr(type_, "__exclude__", [])
-
-            # if the type inherits from another mapped type, then it may have
-            # generated resolvers. These will be treated by dataclasses as having
-            # a default value, which will likely cause issues because of keys
-            # that don't have default values. To fix this, we wrap them in
-            # `strawberry.field()` (like when they were originally made), so
-            # dataclasses will ignore them.
-            # TODO: Potentially raise/fix this issue upstream
-            for key in dir(type_):
-                val = getattr(type_, key)
-                if getattr(val, _IS_GENERATED_RESOLVER_KEY, False):
-                    setattr(type_, key, strawberry.field(resolver=val))
-                    generated_field_keys.append(key)
-
-            self._handle_columns(mapper, type_, excluded_keys, generated_field_keys)
-            for key, relationship in mapper.relationships.items():
-                relationship: RelationshipProperty
-                if (
-                    key in excluded_keys
-                    or key in type_.__annotations__
-                    or hasattr(type_, key)
-                ):
-                    continue
-                strawberry_type = self._convert_relationship_to_strawberry_type(
-                    relationship
-                )
-                self._add_annotation(
-                    type_,
-                    key,
+        def do_conversion(type_):
+            return self.convert(
+                type_,
+                model,
+                make_interface,
+                use_federation,
+            )
+
+        return do_conversion
+
+    def convert(
+        self,
+        type_: Any,
+        model: Type[BaseModelType],
+        make_interface=False,
+        use_federation=False,
+    ) -> Any:
+        """
+        Do type conversion. Usually accessed using typical .type decorator. But
+        can also be used as standalone function.
+        """
+        old_annotations = getattr(type_, "__annotations__", {})
+        type_.__annotations__ = {}
+        mapper: Mapper = inspect(model)
+        generated_field_keys = []
+
+        excluded_keys = getattr(type_, "__exclude__", [])
+
+        # if the type inherits from another mapped type, then it may have
+        # generated resolvers. These will be treated by dataclasses as having
+        # a default value, which will likely cause issues because of keys
+        # that don't have default values. To fix this, we wrap them in
+        # `strawberry.field()` (like when they were originally made), so
+        # dataclasses will ignore them.
+        # TODO: Potentially raise/fix this issue upstream
+        for key in dir(type_):
+            val = getattr(type_, key)
+            if getattr(val, _IS_GENERATED_RESOLVER_KEY, False):
+                setattr(type_, key, strawberry.field(resolver=val))
+                generated_field_keys.append(key)
+
+        self._handle_columns(mapper, type_, excluded_keys, generated_field_keys)
+        for key, relationship in mapper.relationships.items():
+            relationship: RelationshipProperty
+            if (
+                key in excluded_keys
+                or key in type_.__annotations__
+                or hasattr(type_, key)
+            ):
+                continue
+            strawberry_type = self._convert_relationship_to_strawberry_type(
+                relationship
+            )
+            self._add_annotation(
+                type_,
+                key,
+                strawberry_type,
+                generated_field_keys,
+            )
+            field = strawberry.field(
+                resolver=self.connection_resolver_for(relationship)
+            )
+            assert not field.init
+            setattr(
+                type_,
+                key,
+                field,
+            )
+        for key, descriptor in mapper.all_orm_descriptors.items():
+            if (
+                key in excluded_keys
+                or key in type_.__annotations__
+                or hasattr(type_, key)
+            ):
+                continue
+            if key in mapper.columns or key in mapper.relationships:
+                continue
+            if key in model.__annotations__:
+                annotation = eval(model.__annotations__[key])
+                for (
+                    sqlalchemy_type,
                     strawberry_type,
-                    generated_field_keys,
+                ) in self.sqlalchemy_type_to_strawberry_type_map.items():
+                    if isinstance(annotation, sqlalchemy_type):
+                        self._add_annotation(
+                            type_, key, strawberry_type, generated_field_keys
+                        )
+                        break
+            elif isinstance(descriptor, AssociationProxy):
+                strawberry_type = self._get_association_proxy_annotation(
+                    mapper, key, descriptor
                 )
+                if strawberry_type is SkipTypeSentinel:
+                    continue
+                self._add_annotation(type_, key, strawberry_type, generated_field_keys)
                 field = strawberry.field(
-                    resolver=self.connection_resolver_for(relationship)
+                    resolver=self.association_proxy_resolver_for(
+                        mapper, descriptor, strawberry_type
+                    )
                 )
                 assert not field.init
-                setattr(
+                setattr(type_, key, field)
+            elif isinstance(descriptor, hybrid_property):
+                if (
+                    not hasattr(descriptor, "__annotations__")
+                    or "return" not in descriptor.__annotations__
+                ):
+                    raise HybridPropertyNotAnnotated(key)
+                annotation = descriptor.__annotations__["return"]
+                if isinstance(annotation, str):
+                    try:
+                        if "typing" in annotation:
+                            # Try to evaluate from existing typing imports
+                            annotation = annotation[7:]
+                        annotation = eval(annotation)
+                    except NameError:
+                        raise UnsupportedDescriptorType(key)
+                self._add_annotation(
                     type_,
                     key,
-                    field,
+                    annotation,
+                    generated_field_keys,
                 )
-            for key, descriptor in mapper.all_orm_descriptors.items():
-                if (
-                    key in excluded_keys
-                    or key in type_.__annotations__
-                    or hasattr(type_, key)
-                ):
-                    continue
-                if key in mapper.columns or key in mapper.relationships:
-                    continue
-                if isinstance(descriptor, AssociationProxy):
-                    strawberry_type = self._get_association_proxy_annotation(
-                        mapper, key, descriptor
-                    )
-                    if strawberry_type is SkipTypeSentinel:
-                        continue
-                    self._add_annotation(
-                        type_, key, strawberry_type, generated_field_keys
-                    )
-                    field = strawberry.field(
-                        resolver=self.association_proxy_resolver_for(
-                            mapper, descriptor, strawberry_type
-                        )
-                    )
-                    assert not field.init
-                    setattr(type_, key, field)
-                elif isinstance(descriptor, hybrid_property):
-                    if (
-                        not hasattr(descriptor, "__annotations__")
-                        or "return" not in descriptor.__annotations__
-                    ):
-                        raise HybridPropertyNotAnnotated(key)
-                    annotation = descriptor.__annotations__["return"]
-                    if isinstance(annotation, str):
-                        try:
-                            if "typing" in annotation:
-                                # Try to evaluate from existing typing imports
-                                annotation = annotation[7:]
-                            annotation = eval(annotation)
-                        except NameError:
-                            raise UnsupportedDescriptorType(key)
-                    self._add_annotation(
-                        type_,
-                        key,
-                        annotation,
-                        generated_field_keys,
-                    )
-                else:
-                    raise UnsupportedDescriptorType(key)
+            else:
+                raise UnsupportedDescriptorType(key)
 
-            # ignore inherited `is_type_of`
-            if "is_type_of" not in type_.__dict__:
-                type_.is_type_of = (
-                    lambda obj, info: type(obj) == model or type(obj) == type_
-                )
+        # ignore inherited `is_type_of`
+        if "is_type_of" not in type_.__dict__:
+            type_.is_type_of = (
+                lambda obj, info: type(obj) == model or type(obj) == type_
+            )
 
-            # need to make fields that are already in the type
-            # (prior to mapping) appear *after* the mapped fields
-            # because the pre-existing fields might have default values,
-            # which will cause the mapped fields to fail
-            # (because they may not have default values)
-            type_.__annotations__.update(old_annotations)
-
-            if make_interface:
-                mapped_type = strawberry.interface(type_)
-            elif use_federation:
-                mapped_type = strawberry.federation.type(type_)
-            else:
-                mapped_type = strawberry.type(type_)
-            self.mapped_types[type_.__name__] = mapped_type
-            setattr(mapped_type, _GENERATED_FIELD_KEYS_KEY, generated_field_keys)
-            setattr(mapped_type, _ORIGINAL_TYPE_KEY, type_)
-            return mapped_type
+        # need to make fields that are already in the type
+        # (prior to mapping) appear *after* the mapped fields
+        # because the pre-existing fields might have default values,
+        # which will cause the mapped fields to fail
+        # (because they may not have default values)
+        type_.__annotations__.update(old_annotations)
 
-        return convert
+        if make_interface:
+            type_name = self.model_to_interface_name(type_)
+            mapped_type = strawberry.interface(type_, name=type_name)
+        else:
+            type_name = self.model_to_type_name(type_)
+            if use_federation:
+                mapped_type = strawberry.federation.type(type_, name=type_name)
+            else:
+                mapped_type = strawberry.type(type_, name=type_name)
+        self.mapped_types[type_name] = mapped_type
+        setattr(mapped_type, _GENERATED_FIELD_KEYS_KEY, generated_field_keys)
+        setattr(mapped_type, _ORIGINAL_TYPE_KEY, type_)
+        return mapped_type
 
     def interface(self, model: Type[BaseModelType]) -> Callable[[Type[object]], Any]:
         """