Implement delete mutation

Forbid passing "insert", "update" or "delete" with each other in an one
argument list.

Part of #142.

Author: Totktonada

README.md

@@ -294,6 +294,7 @@ Consider the following details:
   pass to the `update` argument. This type / argument requires a user to set
   subset of fields of an updating object except primary key parts.
 * A mutation with an `update` argument always return the updated object.
+* The `update` argument is forbidden with `insert` or `delete` arguments.
 * The `update` argument is forbidden in `query` requests.
 * Objects are selected by filters first, then updated using a statement in the
   `update` argument, then connected objects are selected.
@@ -308,7 +309,38 @@ Consider the following details:
 
 #### Delete
 
-TBD
+Example:
+
+```
+mutation delete_user_and_order(
+    $user_id: String,
+    $order_id: String,
+) {
+    user_collection(user_id: $user_id, delete: true) {
+        user_id
+        first_name
+        last_name
+    }
+    order_collection(order_id: $order_id, delete: true) {
+        order_id
+        description
+        in_stock
+    }
+}
+```
+
+Consider the following details:
+
+* There are no special type name for a `delete` argument, it is just Boolean.
+* A mutation with a `delete: true` argument always return the deleted object.
+* The `delete` argument is forbidden with `insert` or `update` arguments.
+* The `delete` argument is forbidden in `query` requests.
+* The same fields traversal order and 'select -> change -> select connected'
+  order of operations for an one field are applied likewise for the `update`
+  argument.
+* The `limit` argument can be used to define how many objects are subject to
+  deletion and `offset` can help with adjusting start point of multi-object
+  delete operation.
 
 ## GraphiQL
 ```

graphql/accessor_general.lua

@@ -950,6 +950,65 @@ local function process_tuple(state, tuple, opts)
     return true
 end
 
+--- Get schema name by a collection name.
+---
+--- @tparam table self data accessor instance
+---
+--- @tparam string collection_name
+---
+--- @treturn string `schema_name`
+local function get_schema_name(self, collection_name)
+    local collection = self.collections[collection_name]
+    assert(collection ~= nil,
+        ('cannot find the collection "%s"'):format(collection_name))
+    local schema_name = collection.schema_name
+    assert(type(schema_name) == 'string',
+        'schema_name must be a string, got ' .. type(schema_name))
+    return schema_name
+end
+
+--- Call one of accessor function: `update_tuple` or `delete_tuple` for each
+--- selected object.
+---
+--- @tparam table self data accessor instance
+---
+--- @tparam string collection_name
+---
+--- @tparam string schema_name
+---
+--- @tparam table selected objects to perform the operation
+---
+--- @tparam string operation 'update_tuple' or 'delete_tuple'
+---
+--- @param[opt] ... parameters to pass to the function
+---
+--- @treturn table `new_objects` list of returned objects (in the order of the
+--- `selected` parameter)
+local function perform_primary_key_operation(self, collection_name, schema_name,
+        selected, operation, ...)
+    check(operation, 'operation', 'string')
+
+    local _, primary_index_meta = get_primary_index_meta(self, collection_name)
+
+    local new_objects = {}
+
+    for _, object in ipairs(selected) do
+        local key = {}
+        for _, field_name in ipairs(primary_index_meta.fields) do
+            table.insert(key, object[field_name])
+        end
+        -- XXX: we can pass a tuple corresponding the object to update_tuple /
+        -- delete_tuple to save one get operation
+        local new_tuple = self.funcs[operation](collection_name, key, ...)
+        local new_object = self.funcs.unflatten_tuple(collection_name,
+            new_tuple, {use_tomap = self.collection_use_tomap[collection_name]},
+            self.default_unflatten_tuple[schema_name])
+        table.insert(new_objects, new_object)
+    end
+
+    return new_objects
+end
+
 --- The function is core of this module and implements logic of fetching and
 --- filtering requested objects.
 ---
@@ -1117,17 +1176,13 @@ local function insert_internal(self, collection_name, from, filter, args, extra)
     local err_msg = '"insert" must be the only argument when it is present'
     assert(next(filter) == nil, err_msg)
     assert(next(args) == nil, err_msg)
+    assert(next(extra.extra_args, next(extra.extra_args)) == nil, err_msg)
     check(from, 'from', 'table')
     -- allow only top level collection
     check(from.collection_name, 'from.collection_name', 'nil')
 
     -- convert object -> tuple (set default values from a schema)
-    local collection = self.collections[collection_name]
-    assert(collection ~= nil,
-        ('cannot find the collection "%s"'):format(collection_name))
-    local schema_name = collection.schema_name
-    assert(type(schema_name) == 'string',
-        'schema_name must be a string, got ' .. type(schema_name))
+    local schema_name = get_schema_name(self, collection_name)
     local default_flatten_object = self.default_flatten_object[schema_name]
     assert(default_flatten_object ~= nil,
         ('cannot find default_flatten_object ' ..
@@ -1164,42 +1219,44 @@ local function update_internal(self, collection_name, extra, selected)
     local xobject = extra.extra_args.update
     if xobject == nil then return nil end
 
-    -- convert xobject -> update statements
-    local collection = self.collections[collection_name]
-    assert(collection ~= nil,
-        ('cannot find the collection "%s"'):format(collection_name))
-    local schema_name = collection.schema_name
-    assert(type(schema_name) == 'string',
-        'schema_name must be a string, got ' .. type(schema_name))
+    local err_msg = '"update" must not be passed with "insert" or "delete" ' ..
+        'arguments'
+    assert(next(extra.extra_args, next(extra.extra_args)) == nil, err_msg)
 
+    -- convert xobject -> update statements
+    local schema_name = get_schema_name(self, collection_name)
     local default_xflatten = self.default_xflatten[schema_name]
     assert(default_xflatten ~= nil,
         ('cannot find default_xflatten ' ..
         'for collection "%s"'):format(collection_name))
-
     local statements = self.funcs.xflatten(collection_name, xobject, {
         service_fields_defaults =
             self.service_fields_defaults[schema_name],
     }, default_xflatten)
 
-    local _, primary_index_meta = get_primary_index_meta(self, collection_name)
-    local new_objects = {}
-    for _, object in ipairs(selected) do
-        local key = {}
-        for _, field_name in ipairs(primary_index_meta.fields) do
-            table.insert(key, object[field_name])
-        end
-        -- XXX: we can pass a tuple corresponding the object to update_tuple to
-        -- save one get operation
-        local new_tuple = self.funcs.update_tuple(collection_name, key,
-            statements)
-        local new_object = self.funcs.unflatten_tuple(collection_name,
-            new_tuple, {use_tomap = self.collection_use_tomap[collection_name]},
-            self.default_unflatten_tuple[schema_name])
-        table.insert(new_objects, new_object)
-    end
+    return perform_primary_key_operation(self, collection_name, schema_name,
+        selected, 'update_tuple', statements)
+end
 
-    return new_objects
+--- Delete an object.
+---
+--- Parameters are the same as for @{select_update}.
+---
+--- @tparam table extra `extra.extra_args.delete` is used
+---
+--- @treturn table `new_objects` list of deleted objects (in the order of the
+--- `selected` parameter)
+local function delete_internal(self, collection_name, extra, selected)
+    if not extra.extra_args.delete then return nil end
+
+    local err_msg = '"delete" must not be passed with "insert" or "update" ' ..
+        'arguments'
+    assert(next(extra.extra_args, next(extra.extra_args)) == nil, err_msg)
+
+    local schema_name = get_schema_name(self, collection_name)
+
+    return perform_primary_key_operation(self, collection_name, schema_name,
+        selected, 'delete_tuple')
 end
 
 --- Set of asserts to check the `funcs` argument of the @{accessor_general.new}
@@ -1234,6 +1291,9 @@ local function validate_funcs(funcs)
     assert(type(funcs.update_tuple) == 'function',
         'funcs.update_tuple must be a function, got ' ..
         type(funcs.update_tuple))
+    assert(type(funcs.delete_tuple) == 'function',
+        'funcs.delete_tuple must be a function, got ' ..
+        type(funcs.delete_tuple))
 end
 
 --- This function is called on first select related to a query. Its purpose is
@@ -1685,6 +1745,10 @@ function accessor_general.new(opts, funcs)
                     selected)
                 if updated ~= nil then return updated end
 
+                local deleted = delete_internal(self, collection_name, extra,
+                    selected)
+                if deleted ~= nil then return deleted end
+
                 return selected
             end,
             list_args = list_args,

graphql/accessor_shard.lua

@@ -470,6 +470,7 @@ function accessor_shard.new(opts, funcs)
         xflatten = funcs.xflatten or xflatten,
         insert_tuple = funcs.insert_tuple or insert_tuple,
         update_tuple = funcs.update_tuple or update_tuple,
+        delete_tuple = funcs.delete_tuple or delete_tuple,
     }
 
     return accessor_general.new(opts, res_funcs)

graphql/accessor_space.lua

@@ -117,6 +117,23 @@ local function update_tuple(collection_name, key, statements, opts)
     return box.space[collection_name]:update(key, statements)
 end
 
+--- Delete tuple by a primary key.
+---
+--- @tparam string collection_name
+---
+--- @param key primary key
+---
+--- @tparam table opts
+---
+--- * tuple (ignored in accessor_space)
+---
+--- @treturn cdata tuple
+local function delete_tuple(collection_name, key, opts)
+    local opts = opts or {}
+    check(opts, 'opts', 'table')
+    return box.space[collection_name]:delete(key)
+end
+
 --- Create a new space data accessor instance.
 function accessor_space.new(opts, funcs)
     local funcs = funcs or {}
@@ -140,6 +157,7 @@ function accessor_space.new(opts, funcs)
         xflatten = funcs.xflatten or xflatten,
         insert_tuple = funcs.insert_tuple or insert_tuple,
         update_tuple = funcs.update_tuple or update_tuple,
+        delete_tuple = funcs.delete_tuple or delete_tuple,
     }
 
     return accessor_general.new(opts, res_funcs)