Swagger.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  Swagger.qm Copyright (C) 2017 - 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.
*/
 
 
// make sure we have the required qore version
 
// try importing JSON and YAML modules
 
 
 
 
 
namespace Swagger {
const LM_IGNORE_MISSING_REQUIRED    = (1 << 0);
 
const LM_LAX_COLLECTIONFORMAT       = (1 << 1);
 
const LM_IGNORE_INVALID_REQUIRED    = (1 << 2);
 
const LM_ACCEPT_INVALID_BODY_PARAMS = (1 << 3);
 
const LM_AUTO_FORM_DATA             = (1 << 4);
 
const LM_ALL = ...;
 
 
const ValidIntFormats = ("int32", "int64");
const ValidNumberFormats = ("double", "float");
const ValidStringFormats = ("binary", "byte", "date", "date-time", "password");
 
const CollectionFormats = ...;
 
 
const ParameterCollectionFormats = ...;
 
 
const ValidIntFormatsHash = map {$1: True}, ValidIntFormats;
const ValidNumberFormatsHash = map {$1: True}, ValidNumberFormats;
const ValidStringFormatsHash = map {$1: True}, ValidStringFormats;
 
const YamlSerialization = {
    "serialize": \make_yaml(),
    "serialize_verbose": string sub (auto val) {return make_yaml(val, BlockStyle);},
    "deserialize": \parse_yaml(),
    "module": "yaml",
};
 
const MimeDataTypes = {
%ifndef NoJson
    MimeTypeJson: (
        "serialize": \make_json(),
        "serialize_verbose": string sub (auto val) {return make_json(val, JGF_ADD_FORMATTING);},
        "deserialize": \parse_json(),
        "module": "json",
    ),
%endif
%ifndef NoYaml
    // issue #3699: more YAML MIME types must be supported
    MimeTypeYaml: YamlSerialization,
    MimeTypeYamlRpc: YamlSerialization,
    "text/yaml": YamlSerialization,
    "application/yaml": YamlSerialization,
%endif
%ifndef NoXml
    MimeTypeXmlApp: (
        "serialize": \make_xml(),
        "serialize_verbose": string sub (auto val) {return make_xml(val, XGF_ADD_FORMATTING);},
        "deserialize": \parse_xml(),
        "module": "xml",
    ),
%endif
    # Content-Type: application/x-www-form-urlencoded
    MimeTypeFormUrlEncoded: (
        "serialize": \mime_get_form_urlencoded_string(),
        "serialize_verbose": \mime_get_form_urlencoded_string(),
        "deserialize": \mime_parse_form_urlencoded_string(),
    ),
    # Content-Type: multipart/form-data (handled manually)
    MimeTypeMultipartFormData: {},
};
 
const SerializationModules = keys (map {$1.module: True}, MimeDataTypes.iterator(), $1.module);
 
const MimeContentTypes = keys MimeDataTypes;
 
const ValidSchemes = ("http", "https", "ws", "wss");
const ValidSchemesHash = map {$1: True}, ValidSchemes;
 
class ObjectBase {
 
public:
 
        hash<auto> vendorExtensions;
 
    constructor();
 
 
 
    constructor(hash<auto> oh);
 
 
    constructor(ObjectBase other);
 
 
 
     initialize(hash<auto> oh);
};
 
class SchemaBase {
 
public:
        *float maximum;
 
        *float minimum;
 
        *bool exclusiveMax;
 
        *bool exclusiveMin;
 
        *int maxLength;
 
        *int minLength;
 
        *string pattern;
 
        *int maxItems;
 
        *int minItems;
 
        *bool uniqueItems;
 
 
        hash<string, bool> enum;
 
        *float multipleOf;
 
 
    constructor(string objType, hash<auto> oh);
 
 
    constructor(SchemaBase other);
 
 
protected:
     auto getExampleValue(string type, *string format);
public:
 
 
protected:
     check(bool serialize, bool request, string type, *string format, *SchemaObject items, string path, string method, string name, reference<auto> value);
public:
 
 
protected:
     checkStringIntern(string path, string method, string name, string value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, list<auto> v, reference<list> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, hash<auto> v, reference<hash> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, int v, reference<auto> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, number v, reference<number> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, float v, reference<number> value);
public:
 
 
protected:
     checkInternNumber(bool serialize, bool request, string type, *string format, string path, string method, string name, auto v, reference<auto> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, binary v, reference value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, string v, reference<auto> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, date v, reference value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, bool v, reference<bool> value);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, nothing v, reference<nothing> value);
public:
 
 
protected:
     checkArrayParam(bool serialize, bool request, SchemaObject items, string path, string method, string name, reference<softlist<auto>> value);
public:
 
 
protected:
      static throwInvalidType(string name, string actual, string expected, auto value);
public:
 
 
 
      static bool checkValueType(reference<auto> value, string type);
};
 
class SwaggerLoader {
 
public:
 
      static SwaggerSchema fromString(string swaggerSpecification, *bool json, *hash<auto> opts);
 
 
      static SwaggerSchema fromFile(string filepath, *hash<auto> opts);
 
 
      static SwaggerSchema fromUrl(string url, *bool json, *hash<auto> opts);
 
 
      static hash<auto> parseSchemaContent(string filepath, string str);
 
      static hash<auto> parseSchemaSource(string str, string ser);
 
      static string detectSourceEncoding(string str);
};
 
class SwaggerSchema : public ObjectBase, public AbstractRestSchemaValidator {
 
public:
 
        string swaggerSpec;
 
        InfoObject info;
 
        PathsObject paths;
 
 
        *string host;
 
 
        *string basePath;
 
 
        hash<string, bool> schemes;
 
 
        hash<string, bool> consumes;
 
 
        hash<string, bool> produces;
 
 
        hash<string, SchemaObject> definitions();
 
 
        hash<string, AbstractParameterObject> parameters();
 
 
        hash<string, ResponseObject> responses;
 
 
        hash<string, SecuritySchemeObject> securityDefinitions;
 
 
        hash<string, softlist<string>> security;
 
 
        list<TagObject> tags;
 
        *ExternalDocumentationObject externalDocs;
 
        const SwaggerOptions = ...;
 
 
protected:
        bool compact_serialization;
 
        *string def_path;
 
 
        *code try_import;
 
        string hash_str;
 
        *int opt_flags;
 
        hash<string, hash<string, SchemaObject>> so_map;
 
public:
 
private:
        *hash<auto> source_definition_hash;
 
public:
 
 
    constructor(string schema_source, hash<auto> oh, *hash<auto> opts) ;
 
 
 
    constructor(LoggerInterface logger, string schema_source, hash<auto> oh, *hash<auto> opts) ;
 
 
protected:
     constructorIntern(string schema_source, hash<auto> oh, *hash<auto> opts);
public:
 
 
    *int getParseFlags();
 
 
    *SchemaObject tryGetSchemaObject(string name, hash<auto> oh, reference<string> hash_str);
 
 
    cacheSchemaObject(string name, string hash_str, SchemaObject so);
 
 
 
    SchemaObject resolveSchemaObject(string name, string refstr, hash<auto> oh);
 
 
 
    ParameterItemsSchemaObject resolveParameterItemsSchemaObject(string name, string refstr, hash<auto> oh);
 
 
 
    AbstractParameterObject resolveParameter(string name, string refstr, hash<auto> oh);
 
 
 
    ResponseObject resolveResponse(string name, string refstr, hash<auto> oh);
 
 
 
protected:
     string getHashImpl();
public:
 
 
 
protected:
     string getTargetUrlImpl();
public:
 
 
 
protected:
     hash<RestSchemaValidator::RestRequestClientInfo> processRequestImpl(string method, string path, auto body, *hash<auto> headers, *softlist<string> content_types);
public:
 
 
 
protected:
     hash<RestSchemaValidator::RestRequestServerInfo> parseRequestImpl(string method, string path, *data http_body, reference<hash> headers);
public:
 
 
 
protected:
     hash<HttpResponseInfo> processResponseImpl(string method, string path, int code, auto response_body, *hash<auto> headers, *softlist<string> content_types);
public:
 
 
 
protected:
     hash<RestSchemaValidator::RestResponseClientInfo> parseResponseImpl(string method, string path, int code, *data response_body, hash<auto> hdr);
public:
 
 
protected:
     fixPath(reference<string> path);
public:
 
 
 
protected:
     hash<string, list<string>> getPathOperationHashImpl();
public:
 
 
 
protected:
     string getBasePathImpl();
public:
 
 
 
protected:
     setBasePathImpl(string basePath);
public:
 
 
 
protected:
     hash<RestQoreExampleCodeInfo> getQoreExampleRequestImpl(string method, string path);
public:
 
 
 
protected:
     hash<RestSchemaValidator::RestExampleRequestInfo> getExampleRequestImpl(string method, string path, *softlist<string> content_types);
public:
 
 
 
protected:
     hash<RestQoreExampleCodeInfo> getQoreExampleResponseImpl(string method, string path, int code);
public:
 
 
 
protected:
     hash<RestExampleResponseInfo> getExampleResponseImpl(string method, string path, int code, *softlist<string> content_types);
public:
 
 
 
protected:
     hash<auto> getExternalReference(string refstr);
public:
 
 
 
protected:
     AbstractDataProvider getDataProviderImpl(HTTPClient rest);
public:
 
 
 
protected:
     setTimeZoneLocaleImpl(*TimeZone tz);
public:
 
 
 
protected:
     *TimeZone getTimeZoneLocaleImpl();
public:
 
 
 
private:
     hash<RestSchemaValidator::RestRequestClientInfo> processRequestIntern(string method, string path, auto body, *hash<auto> headers, *softlist<string> content_types, bool compact_serialization);
public:
 
 
 
private:
     hash<HttpResponseInfo> processResponseIntern(string method, string path, int code, auto response_body, *hash<auto> headers, *softlist<string> content_types, bool compact_serialization);
public:
 
 
 
private:
     bool checkRequestContentTypeHeader(reference<hash<RestRequestClientInfo>> req, auto body, *hash<auto> headers);
public:
 
 
 
private:
     bool checkResponseContentTypeHeader(reference<hash<HttpResponseInfo>> resp, auto body, *hash<auto> headers);
public:
 
 
 
private:
     bool checkResponseTextPlain(reference<hash<HttpResponseInfo>> resp, auto body, hash<string, bool> mime_types, *list<auto> content_types);
public:
 
 
private:
     SchemaObject processDefinition(string key, auto value);
public:
 
};
 
class InfoObject : public ObjectBase {
 
public:
        string title;
 
        *string desc;
 
        *string termsOfService;
 
        string version;
 
        *ContactObject contact;
 
        *LicenseObject license;
 
 
    constructor(hash<auto> oh) ;
 
};
 
class ContactObject : public ObjectBase {
 
public:
        *string name;
 
        *string url;
 
        *string email;
 
 
    constructor(hash<auto> oh) ;
 
};
 
class LicenseObject : public ObjectBase {
 
public:
        string name;
 
        *string url;
 
 
    constructor(hash<auto> oh) ;
 
};
 
 
class PathComponent {
 
public:
protected:
        string pfx;
 
        string name;
 
        *PathComponent wildcard;
 
        *PathItemObject pio;
 
        hash<string, PathComponent> paths;
 
public:
 
    constructor(hash<auto> oh, string pfx, SwaggerSchema swagger);
 
 
protected:
     constructor(string full_path, list<auto> l, int offset, hash<auto> oh);
public:
 
 
protected:
     add(string full_path, list<auto> l, int offset, hash<auto> oh, SwaggerSchema swagger);
public:
 
 
 
    PathItemObject match(list<auto> path);
 
 
 
    *PathItemObject tryMatch(list<auto> path);
 
 
 
    getPathOperationHash(reference<hash<string, list<string>>> h);
 
};
 
class PathsObject : public ObjectBase {
 
public:
protected:
        PathComponent paths;
 
public:
 
 
    constructor(hash<auto> oh, SwaggerSchema swagger) ;
 
 
 
    PathItemObject match(string path);
 
 
 
    *PathItemObject tryMatch(string path);
 
 
 
    hash<string, list<string>> getPathOperationHash();
 
};
 
 
class PathItemObject : public ObjectBase {
 
public:
 
        *string ref;
 
 
        hash<string, AbstractParameterObject> parameters();
 
        AbstractParameterObject body;
 
protected:
 
        hash<string, OperationObject> operations;
 
public:
 
 
    constructor(string path, hash<auto> oh, SwaggerSchema swagger) ;
 
 
 
    OperationObject getOperation(string method, string path);
 
 
 
    softlist getMethods();
 
};
 
class OperationObject : public ObjectBase {
 
public:
        string path;
 
        string method;
 
 
        list tags;
 
        *string summary;
 
        *string desc;
 
 
        bool deprec = False;
 
        *ExternalDocumentationObject externalDocs;
 
 
        *string operationId;
 
 
        hash<string, bool> consumes;
 
 
        hash<string, bool> produces;
 
 
        hash<string, AbstractParameterObject> parameters();
 
        AbstractParameterObject body;
 
        hash<string, AbstractParameterObject> formData;
 
        ResponsesObject responses;
 
 
        list<string> schemes;
 
 
        list<hash<string, list<string>>> security;
 
 
    constructor(string path, string method, hash<auto> oh, SwaggerSchema swagger) ;
 
 
    *data getRequestBody(PathItemObject pio, auto body, reference<hash<auto>> headers);
 
 
 
    validateRequest(bool serialize, PathItemObject pio, reference<hash<UriQueryInfo>> h, reference<auto> body, reference<hash> headers, *reference<hash<string, bool>> mime_types);
 
 
 
    parseRequest(PathItemObject pio, reference<hash<UriQueryInfo>> h, reference<auto> body, reference<hash> headers);
 
 
    validateResponse(string method, string path, PathItemObject pio, int http_code, reference<auto> response_body, reference<hash<string, bool>> mime_types, bool deserialize = True);
 
 
 
    hash<RestQoreExampleCodeInfo> getQoreExampleRequest(string method, string path, PathItemObject pio, SwaggerSchema swagger);
 
 
 
    hash<RestSchemaValidator::RestExampleRequestInfo> getExampleRequest(string method, string path, PathItemObject pio, SwaggerSchema swagger, reference rbody);
 
 
 
    hash<RestQoreExampleCodeInfo> getQoreExampleResponse(string method, string path, int code);
 
 
 
    hash<RestExampleResponseInfo> getExampleResponse(string method, string path, int code, reference<auto> body);
 
 
protected:
     getQoreExampleParams(reference<hash<auto>> query, reference<hash<auto>> headers, hash<string, AbstractParameterObject> parameters, *hash<string, AbstractParameterObject> child_params);
public:
 
 
protected:
     doDefaultParams(reference<hash<UriQueryInfo>> h, reference<hash> headers, reference<auto> body, hash<string, AbstractParameterObject> parameters, *hash<string, AbstractParameterObject> child_params);
public:
 
 
protected:
     checkMissingParams(hash<UriQueryInfo> h, *hash<auto> headers, auto body, hash<string, AbstractParameterObject> parameters, *hash<string, AbstractParameterObject> child_params);
public:
 
 
 
protected:
     *ResponseObject getResponse(int code);
public:
 
 
protected:
     error(string err, string fmt);
public:
 
};
 
class ExternalDocumentationObject : public ObjectBase {
 
public:
        *string desc;
 
        string url;
 
 
    constructor(hash<auto> oh) ;
 
};
 
 
class AbstractParameterObject : public ObjectBase {
 
public:
 
        string name;
 
 
        string inLoc;
 
        *string desc;
 
 
        bool required = False;
 
protected:
        const OtherParameterMap = ...;
 
 
public:
 
 
    constructor(hash<auto> oh, *int opt_flags) ;
 
 
    abstract check(bool serialize, bool request, string path, string method, string name, reference value);
 
    auto getDefaultValue();
 
 
      static AbstractParameterObject newParameter(string name, hash<auto> oh, SwaggerSchema swagger);
};
 
class BodyParameter : public AbstractParameterObject {
 
public:
        SchemaObject schema;
 
 
    constructor(hash<auto> oh, SwaggerSchema swagger) ;
 
 
    check(bool serialize, bool request, string path, string method, string name, reference value);
 
 
    string getQoreExample(reference<hash<RestQoreExampleCodeInfo>> rv);
 
 
    // returns an example value for a REST API call
    auto getExampleValue();
 
};
 
class OtherParameter : public AbstractParameterObject, public SchemaBase {
 
public:
 
        string type;
 
        *string format;
 
 
        bool allowEmptyValue = False;
 
        *ParameterItemsSchemaObject items;
 
 
        *string collectionFormat;
 
 
        auto defaultVal;
 
        const ParameterTypes = ...;
 
 
 
    constructor(string name, hash<auto> oh, SwaggerSchema swagger) ;
 
 
    check(bool serialize, bool request, string path, string method, string name, reference<auto> value);
 
 
    auto getDefaultValue();
 
 
    auto getExampleValue();
 
 
protected:
      static checkValueType(reference<auto> value, string type, *SchemaObject items, *string loc);
public:
 
};
 
class ResponsesObject : public ObjectBase {
 
public:
        // The documentation of responses other than the ones declared for specific HTTP response codes.
        ResponseObject defaultResp;
 
        // A hash mapping HTTP status codes to @ref ResponseObject "ResponseObjects".
        hash<string, ResponseObject> responses;
 
 
    constructor(string path, string method, hash<auto> oh, SwaggerSchema swagger) ;
 
};
 
class ResponseObject : public ObjectBase {
 
public:
        string desc;
 
 
        *SchemaObject schema;
 
 
        hash<auto> headers;
 
 
        hash examples;
 
 
protected:
     constructor(string key, hash<auto> oh, SwaggerSchema swagger) ;
public:
 
 
 
      static ResponseObject newResponse(string key, hash<auto> oh, SwaggerSchema swagger);
};
 
class HeaderObject : public ObjectBase, public SchemaBase {
 
public:
        *string desc;
 
 
        string type;
 
        *string format;
 
        *SchemaObject items;
 
 
        *string collectionFormat;
 
 
        auto defaultVal;
 
 
    constructor(hash<auto> oh, SwaggerSchema swagger) ;
 
 
protected:
      static checkValueType(reference<auto> value, string type, *SchemaObject items, *string loc);
public:
 
};
 
class TagObject : public ObjectBase {
 
public:
        string name;
 
        *string desc;
 
        *ExternalDocumentationObject externalDocs;
 
 
    constructor(hash<auto> oh) ;
 
};
 
class SchemaObject : public ObjectBase, public SchemaBase {
 
public:
        string name;
 
 
        string type;
 
        *string format;
 
        *string title;
 
        *string desc;
 
        *SchemaObject items;
 
        auto defaultVal;
 
        *int maxProperties;
 
        *int minProperties;
 
 
        bool nullable = False;
 
 
        hash<string, SchemaObject> properties;
 
 
        auto additionalProperties;
 
 
        hash<string, bool> required;
 
 
        *string discriminator;
 
 
        bool readOnly = False;
 
 
        list<SchemaObject> allOf();
 
 
        *XmlObject xml;
 
        *ExternalDocumentationObject externalDocs;
 
        auto example;
 
        const ScalarTypes = ...;
 
 
        const ReferenceTypes = ...;
 
 
 
protected:
     constructor(string name, hash<auto> oh, SwaggerSchema swagger, *string hash_str, *bool require_items) ;
public:
 
 
    string getQoreExample(reference<hash<RestQoreExampleCodeInfo>> rv, string name, bool decl);
 
 
    // returns an example value for a REST API call
    auto getExampleValue();
 
 
    check(bool serialize, bool request, string path, string method, string name, reference<auto> value);
 
 
protected:
     checkObjectProperty(string name, string prop);
public:
 
 
protected:
     checkIntern(bool serialize, bool request, string type, *string format, string path, string method, string name, hash<auto> v, reference<hash<auto>> value);
public:
 
 
protected:
      static checkValueType(reference<auto> value, string type, *SchemaObject items, *string loc);
public:
 
 
 
      static SchemaObject newSchemaObject(string name, hash<auto> oh, SwaggerSchema swagger, *bool require_items);
 
 
      static SchemaObject newSchemaObject(string name, auto error, SwaggerSchema swagger);
};
 
class ParameterItemsSchemaObject : public SchemaObject {
 
public:
 
        *string collectionFormat;
 
 
protected:
     constructor(string name, hash<auto> oh, SwaggerSchema swagger) ;
public:
 
 
 
      static ParameterItemsSchemaObject newSchemaObject(string name, hash<auto> oh, SwaggerSchema swagger);
 
 
      static ParameterItemsSchemaObject newSchemaObject(string name, auto error, SwaggerSchema swagger);
};
 
 
class XmlObject : public ObjectBase {
 
public:
 
        *string name;
 
        *string ns;
 
        *string prefix;
 
        bool attribute = False;
 
 
        bool wrapped = False;
 
 
    constructor(hash<auto> oh) ;
 
};
 
 
class SecuritySchemeObject : public ObjectBase {
 
public:
        string type;
 
        *string desc;
 
 
        *string name;
 
 
        *string inLoc;
 
 
        *string flow;
 
 
        *string authorizationUrl;
 
 
        *string tokenUrl;
 
 
        *ScopesObject scopes;
 
 
    constructor(hash<auto> oh) ;
 
};
 
class ScopesObject : public ObjectBase {
 
public:
 
        hash<string, string> fields;
 
 
    constructor(hash<auto> oh) ;
 
};
};
 
// private namespace for internal definitions
namespace Priv {
    // a set of string values
    const SwaggerListToStringSet = -1;
    // a set of any type that can be converted to a string
    const SwaggerListToAnySet = -2;
    const SwaggerListToHashOfStrings = -3;
 
    const TypeMap = ...;
 
 
 
    required_field(string objType, hash<auto> oh, string name, int typeCode, reference<auto> target, *int opt_flags);
 
 
 
    required_field(string objType, hash<auto> oh, string name, hash<string, bool> typeCodes, reference<auto> target);
 
 
 
    bool optional_field(string objType, hash<auto> oh, string name, int typeCode, reference<auto> target, *int opt_flags);
 
 
 
    bool optional_field(string objType, hash<auto> oh, string name, hash<string, bool> typeCodes, reference<auto> target);
 
 
    *bool check_type_code(string objType, hash<auto> oh, string name, auto val, int typeCode, *int opt_flags);
 
 
    get_value(string objType, string name, int typeCode, auto val, reference<auto> target);
 
 
    string get_qore_type(string name, string type, *string format, *SchemaObject items);
 
};