appwrite 2.4.0 → 4.0.0

data/lib/appwrite/services/functions.rb

@@ -1,33 +1,63 @@
+#frozen_string_literal: true
+
 module Appwrite
     class Functions < Service
 
-        def list(search: nil, limit: nil, offset: nil, order_type: nil)
+        # Get a list of all the project's functions. You can use the query params to
+        # filter your results.
+        #
+        # @param [string] search Search term to filter your list results. Max length: 256 chars.
+        # @param [number] limit Maximum number of functions to return in response. By default will return maximum 25 results. Maximum of 100 results allowed per request.
+        # @param [number] offset Offset value. The default value is 0. Use this value to manage pagination. [learn more about pagination](https://appwrite.io/docs/pagination)
+        # @param [string] cursor ID of the function used as the starting point for the query, excluding the function itself. Should be used for efficient pagination when working with large sets of data. [learn more about pagination](https://appwrite.io/docs/pagination)
+        # @param [string] cursor_direction Direction of the cursor.
+        # @param [string] order_type Order result by ASC or DESC order.
+        #
+        # @return [FunctionList]
+        def list(search: nil, limit: nil, offset: nil, cursor: nil, cursor_direction: nil, order_type: nil)
             path = '/functions'
 
-            params = {}
-
-            if !search.nil?
-                params[:search] = search
-            end
-
-            if !limit.nil?
-                params[:limit] = limit
-            end
-
-            if !offset.nil?
-                params[:offset] = offset
-            end
+            params = {
+                search: search,
+                limit: limit,
+                offset: offset,
+                cursor: cursor,
+                cursorDirection: cursor_direction,
+                orderType: order_type,
+            }
+
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::FunctionList
+            )
+        end
 
-            if !order_type.nil?
-                params[:orderType] = order_type
+        # Create a new function. You can pass a list of
+        # [permissions](/docs/permissions) to allow different project users or team
+        # with access to execute the function using the client API.
+        #
+        # @param [string] function_id Function ID. Choose your own unique ID or pass the string &quot;unique()&quot; to auto generate it. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can&#039;t start with a special char. Max length is 36 chars.
+        # @param [string] name Function name. Max length: 128 chars.
+        # @param [array] execute An array of strings with execution permissions. By default no user is granted with any execute permissions. [learn more about permissions](https://appwrite.io/docs/permissions) and get a full list of available permissions.
+        # @param [string] runtime Execution runtime.
+        # @param [object] vars Key-value JSON object that will be passed to the function as environment variables.
+        # @param [array] events Events list.
+        # @param [string] schedule Schedule CRON syntax.
+        # @param [number] timeout Function maximum execution time in seconds.
+        #
+        # @return [Function]
+        def create(function_id:, name:, execute:, runtime:, vars: nil, events: nil, schedule: nil, timeout: nil)
+            if function_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "functionId"')
             end
 
-            return @client.call('get', path, {
-                'content-type' => 'application/json',
-            }, params);
-        end
-
-        def create(name:, execute:, runtime:, vars: nil, events: nil, schedule: nil, timeout: nil)
             if name.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "name"')
             end
@@ -42,41 +72,58 @@ module Appwrite
 
             path = '/functions'
 
-            params = {}
-
-            if !name.nil?
-                params[:name] = name
-            end
-
-            if !execute.nil?
-                params[:execute] = execute
-            end
-
-            if !runtime.nil?
-                params[:runtime] = runtime
-            end
-
-            if !vars.nil?
-                params[:vars] = vars
-            end
-
-            if !events.nil?
-                params[:events] = events
-            end
-
-            if !schedule.nil?
-                params[:schedule] = schedule
-            end
-
-            if !timeout.nil?
-                params[:timeout] = timeout
-            end
+            params = {
+                functionId: function_id,
+                name: name,
+                execute: execute,
+                runtime: runtime,
+                vars: vars,
+                events: events,
+                schedule: schedule,
+                timeout: timeout,
+            }
+
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Function
+            )
+        end
 
-            return @client.call('post', path, {
-                'content-type' => 'application/json',
-            }, params);
+        # Get a list of all runtimes that are currently active in your project.
+        #
+        #
+        # @return [RuntimeList]
+        def list_runtimes()
+            path = '/functions/runtimes'
+
+            params = {
+            }
+
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::RuntimeList
+            )
         end
 
+        # Get a function by its unique ID.
+        #
+        # @param [string] function_id Function ID.
+        #
+        # @return [Function]
         def get(function_id:)
             if function_id.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "functionId"')
@@ -85,13 +132,33 @@ module Appwrite
             path = '/functions/{functionId}'
                 .gsub('{functionId}', function_id)
 
-            params = {}
+            params = {
+            }
 
-            return @client.call('get', path, {
-                'content-type' => 'application/json',
-            }, params);
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Function
+            )
         end
 
+        # Update function by its unique ID.
+        #
+        # @param [string] function_id Function ID.
+        # @param [string] name Function name. Max length: 128 chars.
+        # @param [array] execute An array of strings with execution permissions. By default no user is granted with any execute permissions. [learn more about permissions](https://appwrite.io/docs/permissions) and get a full list of available permissions.
+        # @param [object] vars Key-value JSON object that will be passed to the function as environment variables.
+        # @param [array] events Events list.
+        # @param [string] schedule Schedule CRON syntax.
+        # @param [number] timeout Maximum execution time in seconds.
+        #
+        # @return [Function]
         def update(function_id:, name:, execute:, vars: nil, events: nil, schedule: nil, timeout: nil)
             if function_id.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "functionId"')
@@ -108,37 +175,33 @@ module Appwrite
             path = '/functions/{functionId}'
                 .gsub('{functionId}', function_id)
 
-            params = {}
-
-            if !name.nil?
-                params[:name] = name
-            end
-
-            if !execute.nil?
-                params[:execute] = execute
-            end
-
-            if !vars.nil?
-                params[:vars] = vars
-            end
-
-            if !events.nil?
-                params[:events] = events
-            end
-
-            if !schedule.nil?
-                params[:schedule] = schedule
-            end
-
-            if !timeout.nil?
-                params[:timeout] = timeout
-            end
-
-            return @client.call('put', path, {
-                'content-type' => 'application/json',
-            }, params);
+            params = {
+                name: name,
+                execute: execute,
+                vars: vars,
+                events: events,
+                schedule: schedule,
+                timeout: timeout,
+            }
+
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'PUT',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Function
+            )
         end
 
+        # Delete a function by its unique ID.
+        #
+        # @param [string] function_id Function ID.
+        #
+        # @return []
         def delete(function_id:)
             if function_id.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "functionId"')
@@ -147,211 +210,380 @@ module Appwrite
             path = '/functions/{functionId}'
                 .gsub('{functionId}', function_id)
 
-            params = {}
+            params = {
+            }
+
+            headers = {
+                "content-type": 'application/json',
+            }
 
-            return @client.call('delete', path, {
-                'content-type' => 'application/json',
-            }, params);
+            @client.call(
+                method: 'DELETE',
+                path: path,
+                headers: headers,
+                params: params,
+            )
         end
 
-        def list_executions(function_id:, search: nil, limit: nil, offset: nil, order_type: nil)
+        # Get a list of all the project's code deployments. You can use the query
+        # params to filter your results.
+        #
+        # @param [string] function_id Function ID.
+        # @param [string] search Search term to filter your list results. Max length: 256 chars.
+        # @param [number] limit Maximum number of deployments to return in response. By default will return maximum 25 results. Maximum of 100 results allowed per request.
+        # @param [number] offset Offset value. The default value is 0. Use this value to manage pagination. [learn more about pagination](https://appwrite.io/docs/pagination)
+        # @param [string] cursor ID of the deployment used as the starting point for the query, excluding the deployment itself. Should be used for efficient pagination when working with large sets of data. [learn more about pagination](https://appwrite.io/docs/pagination)
+        # @param [string] cursor_direction Direction of the cursor.
+        # @param [string] order_type Order result by ASC or DESC order.
+        #
+        # @return [DeploymentList]
+        def list_deployments(function_id:, search: nil, limit: nil, offset: nil, cursor: nil, cursor_direction: nil, order_type: nil)
             if function_id.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "functionId"')
             end
 
-            path = '/functions/{functionId}/executions'
+            path = '/functions/{functionId}/deployments'
                 .gsub('{functionId}', function_id)
 
-            params = {}
+            params = {
+                search: search,
+                limit: limit,
+                offset: offset,
+                cursor: cursor,
+                cursorDirection: cursor_direction,
+                orderType: order_type,
+            }
+
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::DeploymentList
+            )
+        end
 
-            if !search.nil?
-                params[:search] = search
+        # Create a new function code deployment. Use this endpoint to upload a new
+        # version of your code function. To execute your newly uploaded code, you'll
+        # need to update the function's deployment to use your new deployment UID.
+        # 
+        # This endpoint accepts a tar.gz file compressed with your code. Make sure to
+        # include any dependencies your code has within the compressed file. You can
+        # learn more about code packaging in the [Appwrite Cloud Functions
+        # tutorial](/docs/functions).
+        # 
+        # Use the "command" param to set the entry point used to execute your code.
+        #
+        # @param [string] function_id Function ID.
+        # @param [string] entrypoint Entrypoint File.
+        # @param [file] code Gzip file with your code package. When used with the Appwrite CLI, pass the path to your code directory, and the CLI will automatically package your code. Use a path that is within the current directory.
+        # @param [boolean] activate Automatically activate the deployment when it is finished building.
+        #
+        # @return [Deployment]
+        def create_deployment(function_id:, entrypoint:, code:, activate:, on_progress: nil)
+            if function_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "functionId"')
             end
 
-            if !limit.nil?
-                params[:limit] = limit
+            if entrypoint.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "entrypoint"')
             end
 
-            if !offset.nil?
-                params[:offset] = offset
+            if code.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "code"')
             end
 
-            if !order_type.nil?
-                params[:orderType] = order_type
+            if activate.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "activate"')
             end
 
-            return @client.call('get', path, {
-                'content-type' => 'application/json',
-            }, params);
+            path = '/functions/{functionId}/deployments'
+                .gsub('{functionId}', function_id)
+
+            params = {
+                entrypoint: entrypoint,
+                code: code,
+                activate: activate,
+            }
+
+            headers = {
+                "content-type": 'multipart/form-data',
+            }
+
+            param_name = 'code'
+
+            @client.chunked_upload(
+                path: path,
+                headers: headers,
+                params: params,
+                param_name: param_name,
+                on_progress: on_progress,
+                response_type: Models::Deployment
+            )
         end
 
-        def create_execution(function_id:, data: nil)
+        # Get a code deployment by its unique ID.
+        #
+        # @param [string] function_id Function ID.
+        # @param [string] deployment_id Deployment ID.
+        #
+        # @return [DeploymentList]
+        def get_deployment(function_id:, deployment_id:)
             if function_id.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "functionId"')
             end
 
-            path = '/functions/{functionId}/executions'
-                .gsub('{functionId}', function_id)
-
-            params = {}
-
-            if !data.nil?
-                params[:data] = data
+            if deployment_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "deploymentId"')
             end
 
-            return @client.call('post', path, {
-                'content-type' => 'application/json',
-            }, params);
+            path = '/functions/{functionId}/deployments/{deploymentId}'
+                .gsub('{functionId}', function_id)
+                .gsub('{deploymentId}', deployment_id)
+
+            params = {
+            }
+
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::DeploymentList
+            )
         end
 
-        def get_execution(function_id:, execution_id:)
+        # Update the function code deployment ID using the unique function ID. Use
+        # this endpoint to switch the code deployment that should be executed by the
+        # execution endpoint.
+        #
+        # @param [string] function_id Function ID.
+        # @param [string] deployment_id Deployment ID.
+        #
+        # @return [Function]
+        def update_deployment(function_id:, deployment_id:)
             if function_id.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "functionId"')
             end
 
-            if execution_id.nil?
-                raise Appwrite::Exception.new('Missing required parameter: "executionId"')
+            if deployment_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "deploymentId"')
             end
 
-            path = '/functions/{functionId}/executions/{executionId}'
+            path = '/functions/{functionId}/deployments/{deploymentId}'
                 .gsub('{functionId}', function_id)
-                .gsub('{executionId}', execution_id)
-
-            params = {}
-
-            return @client.call('get', path, {
-                'content-type' => 'application/json',
-            }, params);
+                .gsub('{deploymentId}', deployment_id)
+
+            params = {
+            }
+
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'PATCH',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Function
+            )
         end
 
-        def update_tag(function_id:, tag:)
+        # Delete a code deployment by its unique ID.
+        #
+        # @param [string] function_id Function ID.
+        # @param [string] deployment_id Deployment ID.
+        #
+        # @return []
+        def delete_deployment(function_id:, deployment_id:)
             if function_id.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "functionId"')
             end
 
-            if tag.nil?
-                raise Appwrite::Exception.new('Missing required parameter: "tag"')
+            if deployment_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "deploymentId"')
             end
 
-            path = '/functions/{functionId}/tag'
+            path = '/functions/{functionId}/deployments/{deploymentId}'
                 .gsub('{functionId}', function_id)
+                .gsub('{deploymentId}', deployment_id)
 
-            params = {}
+            params = {
+            }
 
-            if !tag.nil?
-                params[:tag] = tag
-            end
+            headers = {
+                "content-type": 'application/json',
+            }
 
-            return @client.call('patch', path, {
-                'content-type' => 'application/json',
-            }, params);
+            @client.call(
+                method: 'DELETE',
+                path: path,
+                headers: headers,
+                params: params,
+            )
         end
 
-        def list_tags(function_id:, search: nil, limit: nil, offset: nil, order_type: nil)
+        # 
+        #
+        # @param [string] function_id Function ID.
+        # @param [string] deployment_id Deployment ID.
+        # @param [string] build_id Build unique ID.
+        #
+        # @return []
+        def retry_build(function_id:, deployment_id:, build_id:)
             if function_id.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "functionId"')
             end
 
-            path = '/functions/{functionId}/tags'
-                .gsub('{functionId}', function_id)
-
-            params = {}
-
-            if !search.nil?
-                params[:search] = search
-            end
-
-            if !limit.nil?
-                params[:limit] = limit
-            end
-
-            if !offset.nil?
-                params[:offset] = offset
+            if deployment_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "deploymentId"')
             end
 
-            if !order_type.nil?
-                params[:orderType] = order_type
+            if build_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "buildId"')
             end
 
-            return @client.call('get', path, {
-                'content-type' => 'application/json',
-            }, params);
+            path = '/functions/{functionId}/deployments/{deploymentId}/builds/{buildId}'
+                .gsub('{functionId}', function_id)
+                .gsub('{deploymentId}', deployment_id)
+                .gsub('{buildId}', build_id)
+
+            params = {
+            }
+
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+            )
         end
 
-        def create_tag(function_id:, command:, code:)
+        # Get a list of all the current user function execution logs. You can use the
+        # query params to filter your results. On admin mode, this endpoint will
+        # return a list of all of the project's executions. [Learn more about
+        # different API modes](/docs/admin).
+        #
+        # @param [string] function_id Function ID.
+        # @param [number] limit Maximum number of executions to return in response. By default will return maximum 25 results. Maximum of 100 results allowed per request.
+        # @param [number] offset Offset value. The default value is 0. Use this value to manage pagination. [learn more about pagination](https://appwrite.io/docs/pagination)
+        # @param [string] search Search term to filter your list results. Max length: 256 chars.
+        # @param [string] cursor ID of the execution used as the starting point for the query, excluding the execution itself. Should be used for efficient pagination when working with large sets of data. [learn more about pagination](https://appwrite.io/docs/pagination)
+        # @param [string] cursor_direction Direction of the cursor.
+        #
+        # @return [ExecutionList]
+        def list_executions(function_id:, limit: nil, offset: nil, search: nil, cursor: nil, cursor_direction: nil)
             if function_id.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "functionId"')
             end
 
-            if command.nil?
-                raise Appwrite::Exception.new('Missing required parameter: "command"')
-            end
-
-            if code.nil?
-                raise Appwrite::Exception.new('Missing required parameter: "code"')
-            end
-
-            path = '/functions/{functionId}/tags'
+            path = '/functions/{functionId}/executions'
                 .gsub('{functionId}', function_id)
 
-            params = {}
-
-            if !command.nil?
-                params[:command] = command
-            end
-
-            if !code.nil?
-                params[:code] = code
-            end
-
-            return @client.call('post', path, {
-                'content-type' => 'multipart/form-data',
-            }, params);
+            params = {
+                limit: limit,
+                offset: offset,
+                search: search,
+                cursor: cursor,
+                cursorDirection: cursor_direction,
+            }
+
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::ExecutionList
+            )
         end
 
-        def get_tag(function_id:, tag_id:)
+        # Trigger a function execution. The returned object will return you the
+        # current execution status. You can ping the `Get Execution` endpoint to get
+        # updates on the current execution status. Once this endpoint is called, your
+        # function execution process will start asynchronously.
+        #
+        # @param [string] function_id Function ID.
+        # @param [string] data String of custom data to send to function.
+        # @param [boolean] async Execute code asynchronously. Default value is true.
+        #
+        # @return [Execution]
+        def create_execution(function_id:, data: nil, async: nil)
             if function_id.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "functionId"')
             end
 
-            if tag_id.nil?
-                raise Appwrite::Exception.new('Missing required parameter: "tagId"')
-            end
-
-            path = '/functions/{functionId}/tags/{tagId}'
+            path = '/functions/{functionId}/executions'
                 .gsub('{functionId}', function_id)
-                .gsub('{tagId}', tag_id)
-
-            params = {}
 
-            return @client.call('get', path, {
-                'content-type' => 'application/json',
-            }, params);
+            params = {
+                data: data,
+                async: async,
+            }
+
+            headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Execution
+            )
         end
 
-        def delete_tag(function_id:, tag_id:)
+        # Get a function execution log by its unique ID.
+        #
+        # @param [string] function_id Function ID.
+        # @param [string] execution_id Execution ID.
+        #
+        # @return [Execution]
+        def get_execution(function_id:, execution_id:)
             if function_id.nil?
                 raise Appwrite::Exception.new('Missing required parameter: "functionId"')
             end
 
-            if tag_id.nil?
-                raise Appwrite::Exception.new('Missing required parameter: "tagId"')
+            if execution_id.nil?
+                raise Appwrite::Exception.new('Missing required parameter: "executionId"')
             end
 
-            path = '/functions/{functionId}/tags/{tagId}'
+            path = '/functions/{functionId}/executions/{executionId}'
                 .gsub('{functionId}', function_id)
-                .gsub('{tagId}', tag_id)
+                .gsub('{executionId}', execution_id)
 
-            params = {}
+            params = {
+            }
 
-            return @client.call('delete', path, {
-                'content-type' => 'application/json',
-            }, params);
-        end
+            headers = {
+                "content-type": 'application/json',
+            }
 
+            @client.call(
+                method: 'GET',
+                path: path,
+                headers: headers,
+                params: params,
+                response_type: Models::Execution
+            )
+        end
 
-        protected
-
-        private
     end 
 end