ProviderConfiguration

The ProviderConfiguration section contains main provider settings that determine the connector authorization and behavior.

Most of the behavior settings can be overridden for specific connector objects and stored procedures in the Metadata section.

ProviderConfiguration section contains the following configuration sections and settings:

ProviderConfiguration section example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
"ProviderConfiguration" : {
  "BaseUrl" : "https://api.com/v2",
  "AuthorizationType" : "Basic",
  "TimeStampStoreMode" : "SecondsSinceEpoch",
  "TimeStampNullAs": -1,
  "Headers" : [
      { "Key":"X-API-Version", "Value" : 2 }
  ],
  "ErrorHandling" : {
    "ObjectNotFoundErrors": [ "does not exist", "Invalid global id" ],
    "ErrorMessagePath" : "message;path",
    "Failover": {
      "FailoverErrors": ["Throttled"],
      "MaxRetries": 5,
      "MinDelay": 1000
    }
  },
}

Authorization Settings

The following settings define the web requests authorization to access the source API.

AuthorizationType

The setting which defines how the connector will authorize the web requests.

Valid values are the following:

For example, "AuthorizationType": "Basic".

AuthorizationToken

If you use the AuthorizationToken or OAuth2 type, specify how the authorization token is passed.

TokenName

Name of the parameter which accepts the token value.

TokenType

This setting defines the way to pass the token.

For example:

1
2
3
4
5
"authorizationToken": {
    "TokenType": "Header",
    "TokenName": "Bearer",
    "HeaderName": "Authorization"
}

Valid values are the following:

HeaderName

Name of the header for the Header token type. The default value is Authorization.

OAuth2

The nested object that defines OAuth 2.0 authentication settings for the connection. The structure of the object is the following:

General Settings

BaseUrl

The base URL is the initial part of the GraphQL endpoint URL. All GraphQL endpoints are relative to the base URL. For example, https://api.fireflies.ai/graphql.

Headers

Constant HTTP request headers that are added to every request to the connector. Specify Headers as a JSON array of objects with the Key and Value properties. For example,

1
2
3
4
5
6
"ProviderConfiguration": {
    "Headers": [{
        "Key": "X-API-Version",
        "Value": 2
    }]
}

Headers indicated in the ProviderConfiguration section apply to all REST requests in the connector.

If you want to apply a specific header to a particular object, you can define this setting directly in the Objects configuration section.

DoubleFormat

This setting redefines the format of Double or Single data sent by provider to the source. By default, values ​​are sent in the standard JSON format, but you can change it using this setting. See the available formatting options here. For example:

1
2
3
"ProviderConfiguration" : {
  "DoubleFormat" : "g15"
}

DecimalFormat

This setting redefines the format of Decimal data sent by provider to the source. By default, values ​​are sent in the standard JSON format, but you can change it using this setting. See the available formatting options here. For example:

1
2
3
"ProviderConfiguration" : {
  "DecimalFormat" : "g29"
}

Date and Time Settings

The following settings define the format of date and time data passed from and to the source API.

TimeStampStoreMode

Format in which timestamp data is processed in the connector.

1
2
3
"ProviderConfiguration": {
    "TimeStampStoreMode": "SecondsSinceEpoch"
}

Possible values are:

You can also define or redefine this setting for the particular field in the Metadata section.

DateTimeFormat

This setting defines how to operate with the DateTime data. Use it when the TimeStampStoreMode = Text.

The default value is yyyy-MM-ddTHH:mm:ssZ.

To set the DateTimeFormat to MM-dd-YYYY HH:mm in all objects and all fields specify the following statement.

1
2
3
"ProviderConfiguration": {
    "DateTimeFormat": "MM-dd-YYYY HH:mm"
}

DateFormat

This setting defines how to operate with the Date data. Use it when the TimeStampStoreMode = Text. The default value is yyyy-MM-dd.

TimeFormat

This setting defines how to operate with the Time data. The default value is HH:mm:ssZ.

You can define and redefine these settings for the specific field in the Metadata section.

SourceTimeZone

If a source API returns dates in its own local timezone, while the date value itself doesn't contain the timezone, Skyvia cannot automatically convert such value in UTC. Use this setting to explicitly specify a source timezone. You can do that if the timezone is common, static, and it doesn't need to be selected for connection.

For example:

1
2
3
"ProviderConfiguration" : {
  "SourceTimeZone" : "Eastern Standard Time"
}

RateLimitThrottling

RateLimitThrottling is an allowed number of API requests per unit of time. It helps to avoid the "429 Too Many Requests" error.

If the number of API calls reaches the limit per the specified time interval, the connector waits until this time ends and sends web requests afterward.

RateLimitThrottling works on a single connection and can't prevent the 429 error if there are several parallel connections to one source.

Example of allowing five web requests per 1 second:

1
2
3
4
"RateLimitThrottling": {
    "RequestsLimit": 5,
    "TimeInterval": 1000
}

The RateLimitThrottling setting contains two nested settings.

RequestsLimit

Maximum allowed number of web requests during the time span defined in the TimeInterval setting.

TimeInterval

Time span in milliseconds during which the maximal number of web requests can be sent.

SubRateLimitThrottling

SubRateLimitThrottling is used to configure additional limits on the number of web requests. Use SubRateLimitThrottling when source enforces more than one rate limit at the same time. This approach allows the connector to respect all API rate limits while maintaining the highest possible request throughput and avoiding "429 Too Many Requests" errors.

Like RateLimitThrottling, it has two nested parameters.

RequestsLimit

Maximum allowed number of web requests during the time span defined in the TimeInterval setting.

TimeInterval

Time span in milliseconds during which the maximal number of web requests can be sent.

For example, the Klaviyo API applies combined limits such as “1 request per second (burst) and 15 requests per minute (steady)”. In this case, the broader limit (15 requests per minute) should be configured in RateLimitThrottling, while the stricter limit (1 request per second) should be defined in SubRateLimitThrottling.

1
2
3
4
5
6
7
8
"RateLimitThrottling" : {
	"RequestsLimit" : "15",
	"TimeInterval" : 60000
},
"SubRateLimitThrottling" : {
	"RequestsLimit" : "1",
	"TimeInterval" : 1000
}

SortOperation

Defines sorting parameters that are shared across all objects. It helps to apply the same sorting settings to multiple objects.

You can define or redefine the SortOperation in the Metadata section for particular objects.

The SortOperation setting contains nested settings:

Strategy

Defines how sorting information (fields and directions) is passed to the API request URL. Possible values are:

SortArgument

The name or internal path of the GraphQL argument for the list of sorting fields or joined fields+directions. Used for all strategies except ColumnAndDirectionAsObject.

SortArgumentInQuotes

Determines whether the field name should be enclosed in quotes. Default value is false.

SortPath

The path to the field where the SortArgument should be placed. If SortBasePathPosition = 0, it is treated as an absolute path.

SortBasePathPosition

The index of the base path element to which the SortPath is added (if specified), or where the argument itself is added (if SortPath is not specified). Default value is 0. Either SortPath or SortBasePathPosition must be specified.

DirectionArgument

The name or internal GraphQL path of the argument used for the list of sort fields or joined field+directions values for the SeparateDirectionParameter strategy.

DirectionArgumentInQuotes

Determines whether the direction argument value should be enclosed in quotes. Default value is false.

DirectionPath

The path to the field where the DirectionArgument should be placed. If DirectionBasePathPosition = 0, this is treated as an absolute path.

DirectionBasePathPosition

The index of the base path element to which DirectionPath is added (if specified), or where the argument itself is added (if DirectionPath is not specified). Default value is 0. If direction is used, either DirectionPath or DirectionBasePathPosition must be specified.

AscendingValue

Defines the value for ascending sort direction. Default value is asc.

DescendingValue

Defines the value for descending sort direction. Default is desc.

DirectionSeparator

The separator between a field name and its sort direction for the JoinColumnAndDirection strategy. Default value is a space.

AllowMultipleFields

Defines whether the API allows sorting by multiple fields at the same time.

Example 1. AscendingOnly strategy

For example, there is a single web request parameter for the sorting. Source API supports only the ascending sorting. The sorting field name (field SortPath) without quotation marks, strategy: AscendingOnly:

1
2
3
4
5
6
7
"SortOperation": {
  "Strategy": "AscendingOnly",
  "SortArgument": "sortKey",
  "SortPath": "query.articles",
  "SortBasePathPosition": 0,
  "SortArgumentInQuotes": false
}

As the result the GraphQL query will look like this:

query{articles(sortKey:TITLE){nodes{author{name}}}}

Example 2. SeparateDirectionArgument Strategy

There are two web request parameters for sorting, first is for field name, second is for the direction. Source API supports sorting by multiple fields.

1
2
3
4
5
6
7
8
9
10
11
12
13
"SortOperation": {
  "Strategy": "SeparateDirectionArgument",
  "SortArgument": "field",
  "SortBasePathPosition": 2,
  "SortArgumentInQuotes": false,
  "DirectionArgument": "direction",
  "DirectionBasePathPosition": 2,
  "DirectionArgumentInQuotes": false,
  "AscendingValue": "ASC",
  "DescendingValue": "DESC",
  "AllowMultipleFields": true,
  "ArrayArgument": "sort_params"
}

As the result the GraphQL query will look like this:

query{articles(sort_params:[{field:AUTHOR direction:ASC} {field:TITLE direction:DESC}]){nodes{author{name}}}}

Example 3. ColumnAndDirectionAsObject Strategy

There is a JSON object sort that contains fields. Field name represents the sorting field name, field value represents the sorting direction. Sorting by multiple fields is supported withing this JSON object.

1
2
3
4
5
6
7
8
9
"SortOperation": {
  "Strategy": "ColumnAndDirectionAsObject",
  "SortArgument": "sort",
  "SortBasePathPosition": 2,
  "SortArgumentInQuotes": false,
  "AscendingValue": "ASC",
  "DescendingValue": "DESC",
  "AllowMultipleFields": true
}

As the result the GraphQL query will look like this:

query{articles(sort:{AUTHOR:ASC TITLE:DESC}){nodes{author{name}}}}

PagingStrategy

Pagination is a technique that allows the splitting of the retrieved data into pages according to the defined strategy.

You must define the PagingStrategy if the source uses pagination. Otherwise, the source returns only the first page.

If the pagination differs from object to object, you can define or redefine the PagingStrategy in the Metadata section for particular objects.

Common Paging Strategy Settings

FetchAll

Determines whether all pages of data should be loaded into memory at once. Use it in the situations where the next-page token in a paginated API may become invalid too quickly. For example, while you are processing the records from the current page, the token for the next page may expire. As a result, attempts to read the next page can fail. Valid values are:

If you skip it, the default value is false.

Type

Determines the strategy type. Most PagingStrategy settings depend on the Type specified. The list of possible values is:

See the detailed description of paging strategy types and settings required for them below

WithoutPaging

With this type selected, all the records return at once (when the source doesn't support pagination).

1
2
3
"PagingStrategy": {
    "Type": "WithoutPaging"
}

LimitOffset

Use this type when records are requested in pages using limit and offset parameters.

For example:

1
2
3
4
5
6
7
8
9
"PagingStrategy": {
  "StartIndex": 0,
  "PageSize": 200,
  "LimitArgument": "limit",
  "LimitBasePathPosition": 0,
  "LimitPath": "query.articles", 
  "OffsetArgument": "offset",
  "OffsetBasePathPosition": 2
}   

PageSize

Defines the number of records selected in one call. For example, PageSize = 100 means that the first API call selects the first 100 records, and the subsequent API call selects another 100 from 101 to 200.

StartIndex

This setting defines the offset counting start (first page index). The default value is 0, but some sources require to set it to 1.

TotalRowsPath

Path to search the total number of records on all pages. The reading continues until the total number of records is less than this value. Optional setting. It helps paging strategy more accurately determine when to stop retrieving data.

TotalRowsBasePathPosition

Indicates whether the TotalRowsPath is relative or absolute. When set to a value greater than 0, it is relative.

LimitArgument

Specifies the name or internal path of the GraphQL argument used for the limit value. Default value is limit.

LimitPath

Specifies the path to the field where the LimitArgument should be placed. When LimitBasePathPosition = 0, it is treated as an absolute path.

LimitBasePathPosition

Specifies the index of the base path element where LimitPath (if provided) or the LimitArgument (if LimitPath is not provided) is located. Default value is 0. Either LimitPath or LimitBasePathPosition must be provided.

OffsetArgument

Specifies the name or internal path of the GraphQL argument used for the offset value. Default value is offset.

OffsetPath

Specifies the path to the field where the OffsetArgument should be placed. When OffsetBasePathPosition = 0, this is treated as an absolute path.

OffsetBasePathPosition

Specifies the index of the base path element (object Path) where OffsetPath (if provided) or the OffsetArgument (if OffsetPath is not provided) is located. Default value is 0. Either OffsetPath or OffsetBasePathPosition must be specified.

ExcludeOffsetFromInitialRequest

Determines whether the offset argument should be excluded from the first page request.

PageNo

Use this type when a web request must include the required page number. It is passed as the URL parameter of the request. The number of the next page is specified in every subsequent request.

This paging strategy supports different ways how the data source can indicate whether the next page is available. The data source response may contain either the indicator of the next page's existence or the total number of pages or the total number of records. Alternatively, if the data source does not return any such information, Skyvia can stop querying the next pages if the number of records in the received page is less than the specified page size. If page size is also unknown, Skyvia continues to query next pages till the current page still contains data.

Different settings are used for different ways of detecting whether the next page exists.

For example, it may look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
"PagingStrategy": {
  "Type": "PageNo",
  "StartIndex": 1,
  "PageSize": 10,
  "PageSizeArgument": "limit",
  "PageSizeBasePathPosition": 0,
  "PageSizePath": "query.boards",
  "PageNoArgument": "page",
  "PageNoBasePathPosition": 0,
  "PageNoPath": "query.boards",
  "TotalPageCountBasePathPosition": 0,
  "TotalPageCountPath": null,
  "TotalRowsBasePathPosition": 0,
  "TotalRowsPath": null,
  "HasMoreBasePathPosition": 0,
  "HasMorePath": null
}

All the possible settings which may be defined for the PageNo type are the following:

PageSize

Number of records loaded per page. If it needs to be set in the request, specify it together with the corresponding PageSizeArgument.

You can also use it to determine the end of reading. If you don't specify HasMorePath, TotalPageCountPath and the number of records in the response is less then PageSize, this indicates that the last page was read.

The PageSize setting also has a special value -1, which means that the size of the page is unknown. In this case we do not pass the page size in requests. If you set the PageSize value to -1 and HasMorePath, TotalPageCountPath, are not specified, the reading will continue until the number of records in the response exceeds 0.

PageSizeArgument

The name or internal path of the GraphQL argument used for the page size value.

PageSizePath

The path to the field where the PageSizeArgument is located. When PageSizeBasePathPosition = 0, this is treated as an absolute path.

PageSizeBasePathPosition

Specifies the index of the base path element where PageSizePath (if provided) or the PageSizeArgument (if PageSizePath is not provided) is located. Default value is 0. Either PageSizePath or PageSizeBasePathPosition must be specified.

StartIndex

The index of the first page. Default value is 1.

PageNoArgument

The name or internal path of the GraphQL argument where the page size is located. Required setting.

PageNoPath

The path to the field where the PageNoArgument should be placed. When PageNoBasePathPosition = 0, this is treated as an absolute path.

PageNoBasePathPosition

The index of the base path element where PageNoPath(if provided) or the PageNoArgument (if PageNoPath is not provided) is located. Default value is 0. Either PageNoPath or PageNoBasePathPosition must be specified.

TotalPageCountPath

The path used to locate the total number of pages in the response. If the response does not contain HasMorePath, pages are read until the current page number becomes equal to the total number of pages.

TotalPageCountBasePathPosition

When greater than 0, indicates that TotalPageCountPath is relative, not absolute.

TotalRowsPath

The path to the total number of rows across all pages in the response. If the response does not contain HasMorePath, pages are read until the total number of rows retrieved reaches this value.

TotalRowsBasePathPosition

When set to a value greater than 0, indicates that TotalRowsPath is relative rather than absolute. See also the description of additional GraphQL request fields.

HasMorePath

This setting is used if the response contains an indicator that more pages exist. It specifies the path to a property in the response that indicates if more pages with data are available. If this parameter is specified, TotalPageCountPath is not used and does not need to be defined.

HasMoreBasePathPosition

When greater than 0, indicates that HasMorePath is relative, not absolute.

NextPageToken

Use this paging strategy when the data source returns the token of the subsequent page in the response body or header, and this token must be passed when requesting the next page.

1
2
3
4
5
6
7
8
9
10
11
12
"PagingStrategy": {
  "Type": "NextPageToken",
  "TokenPath": "query.articles.pageInfo.endCursor", // full path
  "TokenBasePathPosition": 0,
  "NextPageArgument": "after",
  "NextPagePath": "query.articles", // full path
  "NextPageBasePathPosition": 0,
  "PageSizeArgument": "first",
  "PageSizePath": "",
  "PageSizeBasePathPosition": 2, // only BasePathPosition set
  "PageSize": 50
}

TokenPath

The path used to search the next page token value in the response. Required parameter.

TokenBasePathPosition

When set to a value greater than 0, indicates that TokenPath is relative, not absolute.

NextPageArgument

The name or internal path of the GraphQL argument used to pass the next page token in the request. Required parameter.

NextPagePath

Specifies the path to the field where the NextPageArgument is located. When the NextPageBasePathPosition = 0, this is treated as an absolute path.

NextPageBasePathPosition

The index of the base path element where NextPagePath (if provided) or the NextPageArgument (if NextPagePath is not provided) is inserted. Default value is 0. Either NextPagePath or NextPageBasePathPosition must be specified.

PageSize

Number of records loaded per page. If it needs to be set in the request, specify it together with the corresponding PageSizeArgument.

PageSizeArgument

The name or internal path of the GraphQL argument used for the page size value.

PageSizePath

The path to the field where the PageSizeArgument is located. When PageSizeBasePathPosition = 0, this is treated as an absolute path.

PageSizeBasePathPosition

Specifies the index of the base path element where PageSizePath (if provided) or the PageSizeArgument (if PageSizePath is not provided) is located. Default value is 0. Either PageSizePath or PageSizeBasePathPosition must be specified.

LimitColumnValueOffset

A strategy that uses a page size and an offset based on the value of a specific field with unique and sorted values (for example, Id, CreatedDate). Data source API must support using this field value as an argument and applying native filtering based on it.

1
2
3
4
5
6
7
8
9
10
11
"PagingStrategy" : {
  "Type" : "LimitColumnValueOffset", 
  "OffsetColumnName": "CreatedDate",
  "ValueDelta": 0,
  "PageSize": 200,
  "LimitArgument": "limit",
  "LimitBasePathPosition": 0,
  "LimitPath": "query.articles",
  "OffsetArgument": "offset",
  "OffsetBasePathPosition": 2
}

OffsetColumnName

The name of the column with unique and sorted values that will be used for pagination filtering.

ValueDelta

Defines an offset value (type: double) that is added to the field value when forming the request for numeric and date/datetime/time fields. For integer fields, only the integer part is used. For date/datetime/time fields, the value represents seconds.

PageSize

Number of records loaded per page. Default value is 100.

LimitArgument

Defines the name or internal path of the GraphQL argument used for the limit value. Default value is limit.

LimitPath

The path to the field where the LimitArgument is located. When LimitBasePathPosition = 0, this is treated as an absolute path.

LimitBasePathPosition

The index of the base path element where LimitPath (if provided) or the LimitArgument (if LimitPath is not provided) is located. Default value is 0. Either LimitPath or LimitBasePathPosition must be specified.

OffsetArgument

Defines the name or internal path of the GraphQL argument used for the offset value. Default value is offset.

OffsetPath

Specifies the path to the field where the OffsetArgument should be placed. When OffsetBasePathPosition = 0, this is treated as an absolute path.

OffsetBasePathPosition

The index of the base path element where OffsetPath (if provided) or the OffsetArgument (if OffsetPath is not provided) is located. Default value is 0. Either OffsetPath or OffsetBasePathPosition must be specified.

ErrorHandling

If the API request returns an error instead of a response, you can process it and determine the connector behavior in case of errors.

For example,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
"ErrorHandling": {
  "ErrorThrowPolicy": "OnEmptyData",
  "ErrorsPath": "errors",
  "ErrorMessagePath": "message;path",
  "FatalErrors": [ "The API call for this organization has exceeded the maximum call rate limit" ],
  "UnauthorizedErrors": [ "token has been expired" ],
  "ObjectNotFoundErrors": [ "may not be available", "not found" ],
  "HtmlResponseError": "Connection settings are invalid. Please check your Domain, User, and/or Password values.",
  "Failover" : {
    "FailoverErrors" : [ "Rate limited due to excessive requests", "Too Many Requests" , "429" ],
    "MaxRetries" : 5,
    "MinDelay" : 500
  }
}

ErrorThrowPolicy

Defines the validation behavior for successful responses (status 200). Responses from unsuccessful requests (status 400+) are always checked for errors. Default value OnEmptyData. Possible values:

ErrorsPath

The path to search for an error or an array of errors in a GraphQL response. Default value is errors. This path is added to the request only for DMLOperation RowErrorHandling.

ErrorMessagePath

The path to search the message in the error response. You can specify several search paths separated by semicolon. In this case, all found values are concatenated into a single error message. If skipped, the default value message;path is used.

Use the $full_error_response$ value to display the whole error response as it is. For example,

1
2
3
"ErrorHandling": {
  "ErrorMessagePath": "$full_error_response$"
}, 

FatalErrors

Use this setting to define the array of the keywords inside the error messages which indicate fatal error. In case of such an error, the execution immediately stops without additional attempts to succeed.

UnauthorizedErrors

Use this setting to configure automatic retry behavior when a request fails. It contains an array of string pieces that represent error messages returned by the server. If the server’s error message contains any of these patterns, the connector treats it as an unauthorized error, it attempts to re-login and continue processing the request.

ObjectNotFoundErrors

When Skyvia queries records with a filter by an ID value, it expects either a record or an empty result. However, some data sources return an error instead of an empty response when you request a non-existing record by an ID. In such cases we need to ignore this error and return an empty result.

By default, Skyvia ignores the messages with the Not Found, No Result found, Gone occurrences. Some data sources may return atypical errors. For such cases, you can specify a JSON array of error message strings to ignore in the ObjectNotFoundErrors setting, for example, "ObjectNotFoundErrors" : [ "may not be available", "not found" ]. The error is ignored if the error message contains at least one of the specified strings.

HtmlResponseError

Use this setting for the cases when the source returns the HTML page instead of an error message.

It allows replacing the HTML page with a readable error message. For example, Connection settings are invalid. Please check your Domain, User, and/or Password values.

In this case, all the error information sent from the source server will be lost.

Failover

Use this setting if you want the connector to retry the API request if it failed with certain errors.

For example, many sources limit the number of API calls per unit of time. If this limit is exceeded (e.g., during the integration execution in Skyvia), the source returns an error, and the execution fails. Failover makes the execution run again automatically after such failure.

FailoverErrors

The array of string message parts of the server error messages that indicate that the execution must try again.

MaxRetries

The maximum number of attempts to retry the request. If all the attempts failed, an error is returned.

The default value is 10.

MinDelay

MinDelay is a minimal delay in milliseconds between attempts to retry a request.

By default, the minimal delay is 500 milliseconds. The delay is not constant and increases with the number of attempts using the exponential backoff algorithm. MinDelay determines only its minimal value.

ReturningStrategy

This section determines how to process the data returned from the data source for INSERT or UPDATE operations.

ReturningStrategy section example:

1
2
3
4
5
6
7
8
9
{
  "ProviderConfiguration": {
     ...
     "ReturningStrategy": {
       "Type":"Row",
       "ReturnDelay": 5000      
      }
   }
}

If you need to override the ReturningStrategy settings for a particular object in the Objects section, you need to specify the separate InsertReturningStrategy and UpdateReturningStrategy settings for INSERT and UPDATE operations respectively.

Type

This setting determines what data is returned from the data source after INSERT or UPDATE. Valid values are the following.

ReturnDelay

Specifies a delay in milliseconds before sending a data retrieval request after a DML operation (for example, INSERT).

This is useful when an API does not immediately return updated data after an insert, and requires a pause before sending a follow-up request.

For example, if ReturnDelay = 30000, the system waits 30 seconds after the insert operation completes and sends request for getting data using the Returning strategy.

This property is used only in strategies where Type = Key.

ConstantParameters

You can set constant parameters added to all GraphQL Queries/Mutations for all the objects. This setting is needed when you have to pass the same parameters for every object, for example, authorization.

For example:

1
2
3
4
5
6
7
8
9
10
11
    "ProviderConfiguration": {      
      "ConstantParameters" : [
        {
          "Argument" : "include_deleted", 
          "Path" : "", // include_deleted is placed directly to the 'articles' node; no additional fields needed
          "BasePathPosition": 2
          "DbType": "Boolean",
          "Value": true
        }
      ]   
    }

As the result the GraphQL query will look like this:

query{articles(include_deleted:true){nodes{author{name}}}}

ConstantParameters is an array of JSON objects with the following settings.

Argument

The name or internal path of the GraphQL argument. Required parameter.

Path

The path to the field where the argument should be placed. When BasePathPosition = 0, this is treated as an absolute path.

BasePathPosition

The index of the base path element where Path (if provided) or the Argument (if Path is not provided) is located. Default value is 0. Either Path or BasePathPosition must be specified.

DbType

Defines the parameter data type. The list of possible data types is the following:

Value

Defines the constant parameter value.