RestClient.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  RestClient.qm Copyright (C) 2013 - 2023 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/
 
// minimum qore version
 
// require type definitions everywhere
 
// enable all warnings
 
// don't use "$" for vars, members, and methods, assume local variable scope
 
 
 
 
 
 
 
/*  Version History - see below in docs
*/
 
namespace RestClient {
 
public hashdecl AuthCodeInfo {
    string response_type = "code";
 
    *string redirect_uri;
 
    *list<string> scopes;
 
    *string state;
};
 
class RestClient : public Qore::HTTPClient, public Logger::LoggerWrapper, public ConnectionProvider::UpdateOptionsInterface {
 
public:
        const DataSerializationSupport = {
%ifndef NoJson
            "json": MimeTypeJson,
%endif
%ifndef NoYaml
            "yaml": MimeTypeYaml,
%endif
%ifndef NoXml
            "xml": MimeTypeXml,
            "rawxml": MimeTypeXmlApp,
%endif
            "url": MimeTypeFormUrlEncoded,
            "text": MimeTypeText,
            "bin": MimeTypeOctetStream,
        };
 
        const DeserializeYaml = {
            "code": "yaml",
            "in": \parse_yaml(),
        };
        const DeserializeXml = {
            "code": "xml",
            "arg": True,
            "in": hash<auto> sub (string xml, reference<string> type) {
                try {
                    on_success type = "xml";
                    return parse_xmlrpc_value(xml);
                } catch (hash<ExceptionInfo> ex) {
                    try {
                        on_success type = "rawxml";
                        return parse_xml(xml);
                    } catch () {
                        rethrow;
                    }
                }
            },
        };
 
        const AcceptList = ...;
 
 
        const Accept = AcceptList.join(",");
 
        const AcceptMap = map {$1: True}, AcceptList;
 
        const Version = "2.0";
 
        const VersionString = sprintf("Qore-RestClient/%s", RestClient::Version);
 
        const DefaultHeaders = {
            "Accept": Accept,
            "User-Agent": RestClient::VersionString,
        };
 
        const DefaultOAuth2RedirectUrl = "auto";
 
        const DefaultOptions = {
            "oauth2_redirect_url": DefaultOAuth2RedirectUrl,
        };
 
 
        const DataSerializationOptions = {
            "auto": True,
%ifndef NoJson
            "json": True,
%endif
%ifndef NoYaml
            "yaml": True,
%endif
%ifndef NoXml
            "rawxml": True,
            "xml": True,
%endif
            "url": True,
            "text": True,
            "bin": True,
        };
 
 
        const EncodingSupport = {
            "gzip": {
                "ce": "gzip",
                "func": \gzip(),
            },
            "bzip2": {
                "ce": "bzip2",
                "func": \bzip2(),
            },
            "deflate": {
                "ce": "deflate",
                "func": \compress(),
            },
            "identity": {
                "ce": NOTHING,
            },
        };
 
        const CompressionThreshold = 1024;
 
 
        const OAuth2GrantOptions = {
            "authorization_code": (
                "oauth2_auth_url",
                "oauth2_client_id",
                "oauth2_client_secret",
                "oauth2_redirect_url",
                "oauth2_token_url",
            ),
            "client_credentials": (
                "oauth2_client_id",
                "oauth2_client_secret",
                "oauth2_token_url",
            ),
            "password": (
                "oauth2_client_id",
                "oauth2_client_secret",
                "oauth2_token_url",
            ),
        };
 
        const OAuth2AuthHeaders = {
            // this will ensure that OAuth2 servers do not prefer XML or other serialization with a different data
            # format (ex: the Salesforce OAuth2 server)
            "Accept": MimeTypeFormUrlEncoded + "," + MimeTypeJson,
        };
 
        const MinimumTokenRefresh = 1m;
 
protected:
        // headers to send with every request
        hash<auto> headers;
        // data serialization code
        string ds;
        // serialization content type
        string sct;
        // send content encoding hash
        *hash<auto> seh;
        // REST schema validator
        RestSchemaValidator::AbstractRestSchemaValidator validator;
        // no_charset option
        *bool noCharset;
 
        string username;
        string password;
 
        string oauth2_grant_type;
        string oauth2_client_id;
        string oauth2_client_secret;
        *softlist<string> oauth2_scopes;
        *hash<auto> oauth2_auth_args;
        string oauth2_auth_url;
        string oauth2_redirect_url;
        string oauth2_token_url;
        string token_type;
        string token;
        string refresh_token;
        bool oauth2_auto_refresh = True;
        date token_timestamp;
 
public:
 
 
    constructor(*hash<auto> opts, *softbool do_not_connect) ;
 
 
 
    clearConnectionPath();
 
 
 
    setSerialization(string data = 'auto');
 
 
 
    setSendEncoding(string enc = 'auto');
 
 
 
    setContentEncoding(string enc = 'auto');
 
 
 
    addDefaultHeaders(hash<auto> h);
 
 
 
    hash<auto> getDefaultHeaders();
 
 
 
    replaceDefaultHeaders(*hash<auto> hdr);
 
 
 
    *string getSendEncoding();
 
 
 
    string getSerialization();
 
 
 
    hash<auto> get(string path, auto body, *reference<hash<auto>> info, *hash<auto> hdr);
 
 
 
    hash<auto> put(string path, auto body, *reference<hash<auto>> info, *hash<auto> hdr);
 
 
 
    hash<auto> patch(string path, auto body, *reference<hash<auto>> info, *hash<auto> hdr);
 
 
 
    hash<auto> post(string path, auto body, *reference<hash<auto>> info, *hash<auto> hdr);
 
 
 
    hash<auto> del(string path, auto body, *reference<hash<auto>> info, *hash<auto> hdr);
 
 
 
    RestSchemaValidator::AbstractRestSchemaValidator getValidator();
 
 
 
    setValidator(RestSchemaValidator::AbstractRestSchemaValidator validator);
 
 
 
    bool usingOAuth2();
 
 
 
    bool requiresOAuth2Token();
 
 
 
    setToken(string token_type, string token, *string refresh_token);
 
 
 
    string getTokenType();
 
 
 
    *string getToken();
 
 
 
    AbstractPollOperation startOAuth2PollSendRecv();
 
 
 
    AbstractPollOperation startOAuth2PollRefreshToken();
 
 
 
    hash<auto> doRequest(string m, string path, auto body, *reference<hash<auto>> info, softbool decode_errors = True, *hash<auto> hdr);
 
 
protected:
     hash<auto> doRequestIntern(string m, string path, auto body, *reference<hash<auto>> info, softbool decode_errors = True, *hash<auto> hdr, *string assume_content_type);
public:
 
 
 
    prepareToSend(string method, reference<string> path, reference<auto> body, *reference<hash<auto>> hdr);
 
 
 
    hash<auto> doValidatedRequest(string m, string path, auto body, *reference<hash<auto>> info, softbool decode_errors = True, *hash<auto> hdr);
 
 
 
    hash<auto> processRestResponse(hash<auto> resp, string method, string path, *reference<hash<auto>> info);
 
 
 
    hash<auto> gotOAuth2LoginInfo(hash<auto> h);
 
 
 
protected:
     setOAuth2LoginInfo(hash<auto> h);
public:
 
 
 
protected:
     *hash<auto> getUpdateOptionsAfterLogin(hash<auto> h);
public:
 
 
 
protected:
     setupAuth(hash<auto> opts);
public:
 
 
 
protected:
     checkOAuth2Options(hash<auto> opts);
public:
 
 
 
protected:
     hash<auto> loginIntern(*reference<hash<auto>> info);
public:
 
 
 
protected:
     AbstractPollOperation startOAuth2AuthPoll(hash<auto> login);
public:
 
 
 
protected:
     hash<auto> oauth2Auth(hash<auto> login, *reference<hash<auto>> info);
public:
 
 
 
protected:
     hash<auto> doOAuth2LoginRequest(string url, hash<auto> login, *reference<hash<auto>> info);
public:
 
 
 
protected:
     *hash<auto> getOAuth2AuthHeaders();
public:
 
 
 
protected:
     hash<auto> getOAuth2LoginInfo(string grant_type);
public:
 
 
 
protected:
     hash<auto> getOAuth2RefreshInfo();
public:
 
 
protected:
     nothing prepareMsg(string method, string path, reference<auto> body, reference<hash<auto>> hdr, string ct = 'Content-Type');
public:
 
 
protected:
     nothing preparePath(reference<string> path);
public:
 
 
protected:
     checkLogin(*reference<hash<auto>> info);
public:
 
 
protected:
     hash<auto> sendAndDecodeResponse(*data body, string m, string path, hash<auto> hdr, *reference<hash<auto>> info, *softbool decode_errors, *string assume_content_type);
public:
 
 
protected:
      static decodeError(hash<auto> h, *reference<hash<auto>> info);
public:
 
 
private:
      static tryDecodeErrorResponse(reference<hash<auto>> h, *reference<hash<auto>> info);
public:
 
 
}; // class RestClient
 
 
class RestConnection : public ConnectionProvider::HttpBasedConnection, public ConnectionProvider::UpdateOptionsInterface {
 
public:
        hash<auto> real_opts;
 
        const ConnectionScheme = <ConnectionSchemeInfo>{
            "cls": Class::forName("RestConnection"),
            "options": HttpConnection::ConnectionScheme.options + {
                "content_encoding": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "this sets the send encoding (if the `send_encoding` option is not set) and the "
                        "response encoding to request",
                    "allowed_values": (
                        <AllowedValueInfo>{
                            "value": "gzip",
                            "desc": "use GNU zip encoding ([RFC 1952](https://tools.ietf.org/html/rfc1952))",
                        }, <AllowedValueInfo>{
                            "value": "bzip2",
                            "desc": "use bzip2 encoding",
                        }, <AllowedValueInfo>{
                            "value": "deflate",
                            "desc": "use the deflate algorithm ([RFC 1951](https://tools.ietf.org/html/rfc1951))",
                        }, <AllowedValueInfo>{
                            "value": "identity",
                            "desc": "use no content encoding",
                        },
                    ),
                },
                "data": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "data serialization options",
                    "allowed_values": (
                        <AllowedValueInfo>{
                            "value": "auto",
                            "desc": "prefers in this order: `json`, `yaml`, `rawxml`, `xml`, `url`, and `text`",
                        }, <AllowedValueInfo>{
                            "value": "bin",
                            "desc": "for binary message bodies without data serialization",
                        }, <AllowedValueInfo>{
                            "value": "json",
                            "desc": "use JSON serialization",
                        }, <AllowedValueInfo>{
                            "value": "rawxml",
                            "desc": "use raw XML serialization",
                        }, <AllowedValueInfo>{
                            "value": "text",
                            "desc": "use only plain text; no serialization is used",
                        }, <AllowedValueInfo>{
                            "value": "url",
                            "desc": "for URL-encoded message bodies",
                        }, <AllowedValueInfo>{
                            "value": "xml",
                            "desc": "use only XML-RPC serialization",
                        }, <AllowedValueInfo>{
                            "value": "yaml",
                            "desc": "use only YAML serialization",
                        },
                    ),
                    "default_value": "auto",
                },
                "headers": <ConnectionOptionInfo>{
                    "type": "hash",
                    "desc": "an optional hash of headers to send with every request, these can also be "
                        "overridden in request method calls",
                },
                "oauth2_auth_args": <ConnectionOptionInfo>{
                    "type": "hash",
                    "desc": "Optional arguments for authentication requests for the `authorization_code` grant type; "
                        "ignored if the `token` option is set.  Note that the `authorization_code` grant type "
                        "requires external user authorization to acquire an access token",
                },
                "oauth2_auth_url": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The OAuth2 authorization URL for the `authorization_code` grant type; ignored "
                        "if the `token` option is set.  Note that the `authorization_code` grant type requires "
                        "external user authorization to acquire an access token",
                },
                "oauth2_auto_refresh": <ConnectionOptionInfo>{
                    "type": "bool",
                    "desc": "If OAuth2 tokens should be automatically refreshed",
                    "default_value": True,
                },
                "oauth2_client_id": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The OAuth2 client ID; ignored if the `token` option is set",
                },
                "oauth2_client_secret": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "the OAuth2 client secret; ignored if the `token` option is set",
                    "sensitive": True,
                },
                "oauth2_grant_type": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The OAuth2 grant type; ignored if the `token` option is set",
                    "allowed_values": (
                        <AllowedValueInfo>{
                            "value": "authorization_code",
                            "desc": "OAuth2 2.0 authorization code grant "
                                "([RFC 6749 authorization code grant]"
                                "(https://datatracker.ietf.org/doc/html/rfc6749//section-4.1)); this grant type "
                                "requires external user authorization to acquire an access token; the "
                                "`oauth2_auth_url` must be set to inform external code where to request "
                                "authorization from the external authorization server",
                        }, <AllowedValueInfo>{
                            "value": "client_credentials",
                            "desc": "OAuth2 2.0 client credentials grant "
                                "([RFC 6749 client credentials grant]"
                                "(https://datatracker.ietf.org/doc/html/rfc6749#section-1.3.4))",
                        }, <AllowedValueInfo>{
                            "value": "password",
                            "desc": "OAuth2 2.0 legacy password grant "
                                "([RFC 6749 password grant]"
                                "(https://datatracker.ietf.org/doc/html/rfc6749#section-1.3.3))",
                        },
                    ),
                },
                "oauth2_redirect_url": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The OAuth2 redirect URL for the `authorization_code` grant type; ignored "
                        "if the `token` option is set.  Note that the `authorization_code` grant type requires "
                        "external user authorization to acquire an access token; the special value `auto` (the "
                        "default) is meant to be interpreted by servers that implement OAuth2 authorization code "
                        "client handling",
                    "default_value": "auto",
                },
                "oauth2_refresh_token": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "the OAuth2 refresh token, if any (complements option `token`)",
                    "sensitive": True,
                },
                "oauth2_scopes": <ConnectionOptionInfo>{
                    "type": "list",
                    "desc": "Space-separated string of OAuth2 scopes to request; ignored if the `token` option is set",
                },
                "oauth2_token_url": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The token URL for OAuth2 flows; ignored if the `token` option is set",
                },
                "password": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The password for authentication; only used if no username or password is set in the URL "
                        "and if the `username` option is also used; conflicts with the `token` option",
                    "sensitive": True,
                },
                "ping_method": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The HTTP method to use for an advanced ping; this and `ping_path` must be set to make "
                        "an HTTP request as a part of the socket polling ping operation; must be a valid HTTP method "
                        "name",
                },
                "ping_path": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The URI path to use for an advanced ping; this and `ping_method` must be made to make "
                        "an HTTP request as a part of the socket polling ping operation.  If the value for this "
                        "option begins with a `/` character, then it replaces any connection path for the REST "
                        "client, otherwise the value is appended to the connection path for the REST client.",
                },
                "ping_headers": <ConnectionOptionInfo>{
                    "type": "hash",
                    "desc": "Any HTTP headers to send when performing an advanced ping operation; ignored if either "
                        "one of `ping_method` and `ping_path` are not set",
                },
                "ping_body": <ConnectionOptionInfo>{
                    "type": "any",
                    "desc": "Any message body to send when performing an advanced ping operation; ignored if either "
                        "one of `ping_method` and `ping_path` are not set or if `ping_method` is `GET`",
                },
                "send_encoding": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "this sets the send encoding",
                    "allowed_values": (
                        <AllowedValueInfo>{
                            "value": "gzip",
                            "desc": "use GNU zip encoding ([RFC 1952](https://tools.ietf.org/html/rfc1952))",
                        }, <AllowedValueInfo>{
                            "value": "bzip2",
                            "desc": "use bzip2 encoding",
                        }, <AllowedValueInfo>{
                            "value": "deflate",
                            "desc": "use the deflate algorithm ([RFC 1951](https://tools.ietf.org/html/rfc1951))",
                        }, <AllowedValueInfo>{
                            "value": "identity",
                            "desc": "use no content encoding",
                        },
                    ),
                },
                "swagger": <ConnectionOptionInfo>{
                    "type": "file-as-string",
                    "desc": "the location of a Swagger schema to use for message validation; processed with "
                        "`FileLocationHandler::getTextFileFromLocation()` "
                        "(ex: `file:///path/to/swagger-schema.json`); conflicts with `validator`",
                    "freeform": True,
                },
                "swagger_base_path": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "in case a REST validator is used, the base path in the schema can be overridden "
                        "with this option (applies to any REST validator; not just Swagger validators)",
                },
                "swagger_lax_parsing": <ConnectionOptionInfo>{
                    "type": "bool",
                    "desc": "try to parse invalid Swagger schemas",
                },
                "token": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "Any bearer token to use for the connection; will be passed as "
                        "`Authorization: Bearer ...` in request headers; this option cannot be used with username "
                        "and password options or authentication information in the URL; if this option is set then "
                        "OAuth2 options are ignored",
                    "sensitive": True,
                },
                "token_type": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The type of `token` to use for the `Authentication` header; ignored if no `token` "
                        "option is set",
                    "default_value": "Bearer",
                },
                "username": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The username for authentication; only used if no username or password is set in the URL "
                        "and if the `password` option is also used; conflicts with the `token` option",
                },
                "validator": <ConnectionOptionInfo>{
                    "type": "any",
                    "desc": "an `AbstractRestSchemaValidator` object for REST message validation; conflicts with "
                        "`swagger`",
                },
            },
        };
 
        const Options = map {$1: True}, keys ConnectionScheme.options;
 
        const OptionList = keys ConnectionScheme.options;
 
        const OAuth2AuthRequestOptions = ...;
 
 
        const OAuth2Options = ...;
 
 
 
        const RCF_OAUTH2_AUTH_CODE = "oauth2-auth-code";
 
protected:
        hash<string, bool> features = {
            CF_LOGGER: True,
        };
 
public:
 
 
    constructor(string name, string description, string url, hash<auto> attributes = {}, hash<auto> options = {})
 ;
 
 
 
    string getOAuth2OptionName(string opt);
 
 
 
    object getPollImpl();
 
 
 
    hash<auto> getOptions();
 
 
    string getType();
 
 
 
    hash<auto> getOAuth2Options();
 
 
 
    hash<auto> processOAuth2TokenResponse(hash<auto> resp);
 
 
 
    DataProvider::AbstractDataProvider getDataProvider();
 
 
 
    bool hasDataProvider();
 
 
 
    Qore::AbstractPollOperation startPollConnect();
 
 
 
      static hash<auto> processOptions(*hash<auto> opts);
 
 
    string getAuthorizationCodeRequest(hash<AuthCodeInfo> info = <AuthCodeInfo>{});
 
 
    /*  @param allow_relative if @ref True then a relative URL (path only) can be returned; the default (@ref False)
        is to return a full URL
 
        @since %RestClient 2.0
    */
    string getAuthUrl(*bool allow_relative);
 
 
    /*  @param allow_relative if @ref True then a relative URL (path only) can be returned; the default (@ref False)
        is to return a full URL
 
        @since %RestClient 2.0
    */
    string getTokenUrl(*bool allow_relative);
 
 
    /*
        @since %RestClient 2.0
    */
protected:
      static softstring getUriValue(auto v);
public:
 
 
protected:
     *hash<auto> processOAuth2TokenResponseImpl(hash<auto> resp);
public:
 
 
protected:
     checkAuthCodeFeature();
public:
 
 
 
protected:
     RestClient getImpl(bool connect = True, *hash<auto> rtopts);
public:
 
 
 
protected:
     pingImpl();
public:
 
 
 
protected:
     *hash<string, bool> getFeaturesImpl();
public:
 
 
protected:
     setChildCapabilities();
public:
 
 
protected:
     hash<ConnectionSchemeInfo> getConnectionSchemeInfoImpl();
public:
 
};
 
 
class RestPingPollOperation : public Qore::AbstractPollOperation {
 
public:
        const SPS_GET_SWAGGER = 'get-swagger';
 
        const SPS_OAUTH2_GET_TOKEN = "oauth2-get-token";
 
        const SPS_OAUTH2_REFRESH_TOKEN = "oauth2-refresh-token";
 
        const SPS_REST_PING = "rest-ping";
 
        const SPS_COMPLETE = "complete";
 
protected:
        RestClient rc;
 
        hash<auto> real_opts;
 
        AbstractPollOperation poller;
 
        bool goal_reached = False;
 
        string method;
 
        string path;
 
        *auto body;
 
        *hash<auto> headers;
 
        string state;
 
        Mutex m();
 
        bool in_refresh;
 
        bool use_path_as_is;
 
public:
 
    constructor(RestClient rc, hash<auto> real_opts);
 
 
 
    string getGoal();
 
 
 
    string getState();
 
 
 
    bool goalReached();
 
 
    *hash<SocketPollInfo> continuePoll();
 
 
protected:
     checkOtherStates();
public:
 
 
protected:
     gotOAuth2LoginInfo(hash<auto> h);
public:
 
 
protected:
     doStartGetToken();
public:
 
 
protected:
     doStartRefresh();
public:
 
 
protected:
     doStartPing();
public:
 
};
};