Use merge for conflicts for now

In the future leaving open the possibility of using dialects for different DB flavors

Author: Guido

src/graphql_sqlalchemy/dialects/__init__.py

@@ -0,0 +1,57 @@
+from sqlalchemy.ext.declarative import DeclarativeMeta
+from graphql import (
+    GraphQLInputObjectType,
+    GraphQLList,
+    GraphQLEnumType,
+    GraphQLInputField,
+    GraphQLNonNull,
+)
+
+from ...names import (
+    get_model_conflict_input_name,
+    get_model_constraint_enum_name,
+    get_model_constraint_key_name,
+    get_model_column_update_enum_name,
+)
+from ...types import Inputs
+from ...helpers import get_table
+from ...inputs import get_where_type
+
+
+def get_constraint_enum(model: DeclarativeMeta) -> GraphQLEnumType:
+    type_name = get_model_constraint_enum_name(model)
+
+    fields = {}
+    for column in get_table(model).primary_key:
+        key_name = get_model_constraint_key_name(model, column, is_primary_key=True)
+        fields[key_name] = key_name
+
+    return GraphQLEnumType(type_name, fields)
+
+
+def get_update_column_enums(model: DeclarativeMeta) -> GraphQLEnumType:
+    type_name = get_model_column_update_enum_name(model)
+
+    fields = {}
+    for column in get_table(model).columns:
+        fields[column.name] = column.name
+
+    return GraphQLEnumType(type_name, fields)
+
+
+def get_conflict_type(model: DeclarativeMeta, inputs: Inputs) -> GraphQLInputObjectType:
+    type_name = get_model_conflict_input_name(model)
+    if type_name in inputs:
+        return inputs[type_name]
+
+    fields = {
+        "constraint": GraphQLInputField(GraphQLNonNull(get_constraint_enum(model))),
+        "update_columns": GraphQLInputField(
+            GraphQLNonNull(GraphQLList(GraphQLNonNull(get_update_column_enums(model))))
+        ),
+        "where": GraphQLInputField(get_where_type(model, inputs)),
+    }
+
+    input_type = GraphQLInputObjectType(type_name, fields)
+    inputs[type_name] = input_type
+    return input_type

src/graphql_sqlalchemy/dialects/pg/__init__.py

@@ -8,6 +8,7 @@
     GraphQLString,
     GraphQLInputFieldMap,
     GraphQLNonNull,
+    GraphQLBoolean,
 )
 
 from .names import (
@@ -16,9 +17,6 @@
     get_model_insert_input_name,
     get_scalar_comparison_name,
     get_model_conflict_input_name,
-    get_model_constraint_enum_name,
-    get_model_constraint_key_name,
-    get_model_column_update_enum_name,
 )
 from .scalars import get_graphql_type_from_column, get_base_comparison_fields, get_string_comparison_fields
 from .types import Inputs
@@ -103,38 +101,13 @@ def get_insert_type(model: DeclarativeMeta, inputs: Inputs) -> GraphQLInputObjec
     return input_type
 
 
-def get_constraint_enum(model: DeclarativeMeta) -> GraphQLEnumType:
-    type_name = get_model_constraint_enum_name(model)
-
-    fields = {}
-    for column in get_table(model).primary_key:
-        key_name = get_model_constraint_key_name(model, column, is_primary_key=True)
-        fields[key_name] = key_name
-
-    return GraphQLEnumType(type_name, fields)
-
-
-def get_update_column_enums(model: DeclarativeMeta) -> GraphQLEnumType:
-    type_name = get_model_column_update_enum_name(model)
-
-    fields = {}
-    for column in get_table(model).columns:
-        fields[column.name] = column.name
-
-    return GraphQLEnumType(type_name, fields)
-
-
 def get_conflict_type(model: DeclarativeMeta, inputs: Inputs) -> GraphQLInputObjectType:
     type_name = get_model_conflict_input_name(model)
     if type_name in inputs:
         return inputs[type_name]
 
     fields = {
-        "constraint": GraphQLInputField(GraphQLNonNull(get_constraint_enum(model))),
-        "update_columns": GraphQLInputField(
-            GraphQLNonNull(GraphQLList(GraphQLNonNull(get_update_column_enums(model))))
-        ),
-        "where": GraphQLInputField(get_where_type(model, inputs)),
+        "merge": GraphQLInputField(GraphQLNonNull(GraphQLBoolean)),
     }
 
     input_type = GraphQLInputObjectType(type_name, fields)

src/graphql_sqlalchemy/dialects/pg/inputs.py

@@ -4,7 +4,7 @@
 
 from sqlalchemy import Column, or_, and_, not_, true
 from sqlalchemy.sql import ClauseElement
-from sqlalchemy.orm import Query
+from sqlalchemy.orm import Query, Session
 from sqlalchemy.ext.declarative import DeclarativeMeta
 
 
@@ -131,36 +131,54 @@ def resolver(_root: DeclarativeMeta, info: Any, **kwargs: Dict[str, Any]) -> Dec
     return resolver
 
 
+def session_add_object(
+    obj: Dict[str, Any], model: DeclarativeMeta, session: Session, on_conflict: Optional[Dict[str, Any]] = None
+) -> DeclarativeMeta:
+    instance = model()
+    for key, value in obj.items():
+        setattr(instance, key, value)
+
+    if on_conflict and on_conflict["merge"]:
+        session.merge(instance)
+    else:
+        session.add(instance)
+    return instance
+
+
+def session_commit(session: Session) -> None:
+    try:
+        session.commit()
+    except Exception:
+        session.rollback()
+        raise
+
+
 def make_insert_resolver(model: DeclarativeMeta) -> Callable:
     def resolver(
-        _root: DeclarativeMeta, info: Any, objects: List[Dict[str, Any]]
+        _root: DeclarativeMeta, info: Any, objects: List[Dict[str, Any]], on_conflict: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Union[int, List[DeclarativeMeta]]]:
         session = info.context["session"]
         models = []
-        for obj in objects:
-            instance = model()
-            models.append(instance)
-            for key, value in obj.items():
-                setattr(instance, key, value)
 
-            session.add(instance)
+        with session.no_autoflush:
+            for obj in objects:
+                instance = session_add_object(obj, model, session, on_conflict)
+                models.append(instance)
 
-        session.commit()
+        session_commit(session)
         return {"affected_rows": len(models), "returning": models}
 
     return resolver
 
 
 def make_insert_one_resolver(model: DeclarativeMeta) -> Callable:
-    def resolver(_root: DeclarativeMeta, info: Any, object: Dict[str, Any]) -> DeclarativeMeta:
+    def resolver(
+        _root: DeclarativeMeta, info: Any, object: Dict[str, Any], on_conflict: Optional[Dict[str, Any]] = None
+    ) -> DeclarativeMeta:
         session = info.context["session"]
 
-        instance = model()
-        for key, value in object.items():
-            setattr(instance, key, value)
-
-        session.add(instance)
-        session.commit()
+        instance = session_add_object(object, model, session, on_conflict)
+        session_commit(session)
         return instance
 
     return resolver