@redhat-cloud-services/notifications-client 0.0.40 → 1.0.0

package/dist/types/index.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Status = exports.NotificationStatus = exports.HttpType = exports.EventLogEntryActionStatus = exports.Environment = exports.EndpointType = exports.EndpointStatus = exports.EmailSubscriptionType = void 0;
+/**
+ *
+ * @export
+ * @enum {string}
+ */
+exports.EmailSubscriptionType = {
+    Daily: 'DAILY'
+};
+/**
+ *
+ * @export
+ * @enum {string}
+ */
+exports.EndpointStatus = {
+    Ready: 'READY',
+    Unknown: 'UNKNOWN',
+    New: 'NEW',
+    Provisioning: 'PROVISIONING',
+    Deleting: 'DELETING',
+    Failed: 'FAILED'
+};
+/**
+ *
+ * @export
+ * @enum {string}
+ */
+exports.EndpointType = {
+    Webhook: 'webhook',
+    EmailSubscription: 'email_subscription',
+    Camel: 'camel',
+    Ansible: 'ansible',
+    Drawer: 'drawer'
+};
+/**
+ *
+ * @export
+ * @enum {string}
+ */
+exports.Environment = {
+    Prod: 'PROD',
+    Stage: 'STAGE',
+    Ephemeral: 'EPHEMERAL',
+    LocalServer: 'LOCAL_SERVER'
+};
+/**
+ *
+ * @export
+ * @enum {string}
+ */
+exports.EventLogEntryActionStatus = {
+    Sent: 'SENT',
+    Success: 'SUCCESS',
+    Processing: 'PROCESSING',
+    Failed: 'FAILED',
+    Unknown: 'UNKNOWN'
+};
+/**
+ *
+ * @export
+ * @enum {string}
+ */
+exports.HttpType = {
+    Get: 'GET',
+    Post: 'POST',
+    Put: 'PUT'
+};
+/**
+ *
+ * @export
+ * @enum {string}
+ */
+exports.NotificationStatus = {
+    FailedInternal: 'FAILED_INTERNAL',
+    FailedExternal: 'FAILED_EXTERNAL',
+    Processing: 'PROCESSING',
+    Sent: 'SENT',
+    Success: 'SUCCESS'
+};
+/**
+ *
+ * @export
+ * @enum {string}
+ */
+exports.Status = {
+    Up: 'UP',
+    Maintenance: 'MAINTENANCE'
+};

package/dist/utils/base.d.ts

@@ -0,0 +1,84 @@
+import type { Configuration } from './configuration';
+import type { AxiosResponse, AxiosInstance, AxiosRequestConfig } from 'axios';
+export declare const BASE_PATH: string;
+/**
+ *
+ * @export
+ */
+export declare const COLLECTION_FORMATS: {
+    csv: string;
+    ssv: string;
+    tsv: string;
+    pipes: string;
+};
+/**
+ *
+ * @export
+ * @interface RequestArgs
+ */
+export interface RequestArgs {
+    urlObj: URL;
+    options: AxiosRequestConfig;
+    auth?: {
+        authType: AuthTypeEnum;
+        authKey?: string | [string, string[]];
+    }[];
+    serializeData?: unknown;
+}
+export interface ApiConfig {
+    axios: AxiosInstance;
+    configuration?: Configuration;
+}
+export declare const AuthTypeEnum: {
+    readonly Basic: "basic";
+    readonly Bearer: "bearer";
+    readonly Oauth: "oath";
+    readonly InHeader: "inHeader";
+    readonly InQuery: "inQuery";
+};
+export declare type AuthTypeEnum = typeof AuthTypeEnum[keyof typeof AuthTypeEnum];
+export declare type ActionType = (...config: any) => Promise<RequestArgs>;
+/**
+ * Base API to store config, basepath and axios instance.
+ * @export
+ * @class BaseAPI
+ */
+export declare class BaseAPI {
+    protected basePath: string;
+    protected configuration: Configuration | undefined;
+    protected axios: AxiosInstance;
+    /**
+     * Constructor to create baseAPI.
+     * @param { string } basePath basePath of api requests.
+     * @param { { axios: AxiosInstance, configuration: Configuration } } config to be passed down to axios.
+     */
+    constructor(basePath?: string, config?: ApiConfig);
+    private authConfig;
+    /**
+    * Send axios request
+    * @param {Promise<RequestArgs>} request to be send trough axios.
+    * @param {AxiosInstance} axios optional axios instance.
+    * @returns {Promise<AxiosResponse<T>>} promisable axios response.
+    */
+    sendRequest<T>(request: Promise<RequestArgs>, axios?: AxiosInstance, basePath?: string): Promise<AxiosResponse<T>>;
+}
+/**
+ *
+ * Factory for creating API with option to add enpoints to the API.
+ * @param basePath basePath of api requests.
+ * @param { { axios: AxiosInstance, configuration: Configuration } } config to be passed down to axios.
+ * @param actions object with actions to send with axios.
+ * @returns created base API.
+ */
+export declare const APIFactory: <T extends Record<string, ActionType>>(basePath: string, config: ApiConfig, actions: T) => BaseAPI & T;
+export default APIFactory;
+/**
+ *
+ * @export
+ * @class RequiredError
+ * @extends {Error}
+ */
+export declare class RequiredError extends Error {
+    field: string;
+    constructor(field: string, msg?: string);
+}

package/dist/utils/base.js

@@ -0,0 +1,251 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredError = exports.APIFactory = exports.BaseAPI = exports.AuthTypeEnum = exports.COLLECTION_FORMATS = exports.BASE_PATH = void 0;
+// @ts-ignore
+var common_1 = require("./common");
+var axios_1 = require("axios");
+exports.BASE_PATH = "https://console.redhat.com//api/notifications/v1.0".replace(/\/+$/, "");
+/**
+ *
+ * @export
+ */
+exports.COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+exports.AuthTypeEnum = {
+    Basic: 'basic',
+    Bearer: 'bearer',
+    Oauth: 'oath',
+    InHeader: 'inHeader',
+    InQuery: 'inQuery'
+};
+/**
+ * Base API to store config, basepath and axios instance.
+ * @export
+ * @class BaseAPI
+ */
+var BaseAPI = /** @class */ (function () {
+    /**
+     * Constructor to create baseAPI.
+     * @param { string } basePath basePath of api requests.
+     * @param { { axios: AxiosInstance, configuration: Configuration } } config to be passed down to axios.
+     */
+    function BaseAPI(basePath, config) {
+        if (basePath === void 0) { basePath = exports.BASE_PATH; }
+        if (config === void 0) { config = { axios: axios_1.default }; }
+        this.basePath = basePath;
+        this.axios = config.axios;
+        if (config.configuration) {
+            this.configuration = config.configuration;
+            this.basePath = config.configuration.basePath || this.basePath;
+        }
+        // Object.entries(actions).forEach((entry: [string, ActionType]) => {
+        //   Object.assign(this, {
+        //     [entry[0]]: entry[1]
+        //   })
+        // })
+    }
+    BaseAPI.prototype.authConfig = function (_a) {
+        var authType = _a.authType, urlObj = _a.urlObj, options = _a.options, authKey = _a.authKey;
+        return __awaiter(this, void 0, void 0, function () {
+            var localVarQueryParameter, localVarHeaderParameter, localVarHeaderParameter, localVarHeaderParameter;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(authType === exports.AuthTypeEnum.InQuery && typeof authKey === 'string')) return [3 /*break*/, 2];
+                        localVarQueryParameter = {};
+                        return [4 /*yield*/, (0, common_1.setApiKeyToObject)(localVarQueryParameter, authKey, this.configuration)];
+                    case 1:
+                        _b.sent();
+                        (0, common_1.setSearchParams)(urlObj, localVarQueryParameter);
+                        return [3 /*break*/, 9];
+                    case 2:
+                        if (!(authType === exports.AuthTypeEnum.InHeader && typeof authKey === 'string')) return [3 /*break*/, 4];
+                        localVarHeaderParameter = {};
+                        return [4 /*yield*/, (0, common_1.setApiKeyToObject)(localVarHeaderParameter, authKey, this.configuration)];
+                    case 3:
+                        _b.sent();
+                        options.headers = __assign(__assign({}, options.headers), localVarHeaderParameter);
+                        return [3 /*break*/, 9];
+                    case 4:
+                        if (!(authType === exports.AuthTypeEnum.Basic)) return [3 /*break*/, 5];
+                        (0, common_1.setBasicAuthToObject)(options, this.configuration);
+                        return [3 /*break*/, 9];
+                    case 5:
+                        if (!(authType === exports.AuthTypeEnum.Bearer)) return [3 /*break*/, 7];
+                        localVarHeaderParameter = {};
+                        return [4 /*yield*/, (0, common_1.setBearerAuthToObject)(localVarHeaderParameter, this.configuration)];
+                    case 6:
+                        _b.sent();
+                        options.headers = __assign(__assign({}, options.headers), localVarHeaderParameter);
+                        return [3 /*break*/, 9];
+                    case 7:
+                        if (!(authType === exports.AuthTypeEnum.Oauth)) return [3 /*break*/, 9];
+                        localVarHeaderParameter = {};
+                        return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, authKey[0], authKey[1], this.configuration)];
+                    case 8:
+                        _b.sent();
+                        options.headers = __assign(__assign({}, options.headers), localVarHeaderParameter);
+                        _b.label = 9;
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+    * Send axios request
+    * @param {Promise<RequestArgs>} request to be send trough axios.
+    * @param {AxiosInstance} axios optional axios instance.
+    * @returns {Promise<AxiosResponse<T>>} promisable axios response.
+    */
+    BaseAPI.prototype.sendRequest = function (request, axios, basePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, auth, urlObj, options, serializeData, axiosRequestArgs;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, request];
+                    case 1:
+                        _a = _b.sent(), auth = _a.auth, urlObj = _a.urlObj, options = _a.options, serializeData = _a.serializeData;
+                        auth === null || auth === void 0 ? void 0 : auth.forEach(function (_a) {
+                            var authType = _a.authType, authKey = _a.authKey;
+                            return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0: return [4 /*yield*/, this.authConfig({ authType: authType, urlObj: urlObj, options: options, authKey: authKey })];
+                                        case 1:
+                                            _b.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            });
+                        });
+                        if (serializeData) {
+                            options.data = (0, common_1.serializeDataIfNeeded)(serializeData, options, this.configuration);
+                        }
+                        axiosRequestArgs = __assign(__assign({}, options), { url: (this.basePath || basePath) + (0, common_1.toPathString)(urlObj) });
+                        return [2 /*return*/, (axios || this.axios).request(axiosRequestArgs)];
+                }
+            });
+        });
+    };
+    return BaseAPI;
+}());
+exports.BaseAPI = BaseAPI;
+;
+/**
+ *
+ * Factory for creating API with option to add enpoints to the API.
+ * @param basePath basePath of api requests.
+ * @param { { axios: AxiosInstance, configuration: Configuration } } config to be passed down to axios.
+ * @param actions object with actions to send with axios.
+ * @returns created base API.
+ */
+var APIFactory = function (basePath, config, actions) {
+    if (basePath === void 0) { basePath = exports.BASE_PATH; }
+    if (config === void 0) { config = { axios: axios_1.default }; }
+    var api = new BaseAPI(basePath, config);
+    var _loop_1 = function (key) {
+        var _b;
+        var method = actions[key];
+        Object.assign(api, (_b = {}, _b[key] = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var request = method.apply(void 0, args);
+            return api.sendRequest(request);
+        }, _b));
+    };
+    for (var _i = 0, _a = Object.keys(actions); _i < _a.length; _i++) {
+        var key = _a[_i];
+        _loop_1(key);
+    }
+    return api;
+};
+exports.APIFactory = APIFactory;
+exports.default = exports.APIFactory;
+/**
+ *
+ * @export
+ * @class RequiredError
+ * @extends {Error}
+ */
+var RequiredError = /** @class */ (function (_super) {
+    __extends(RequiredError, _super);
+    function RequiredError(field, msg) {
+        var _this = _super.call(this, msg) || this;
+        _this.field = field;
+        _this.name = "RequiredError";
+        return _this;
+    }
+    return RequiredError;
+}(Error));
+exports.RequiredError = RequiredError;

package/dist/utils/common.d.ts

@@ -0,0 +1,54 @@
+import type { Configuration } from "./configuration";
+import type { RequestArgs } from "./base";
+import type { AxiosInstance, AxiosResponse } from 'axios';
+/**
+ *
+ * @export
+ */
+export declare const DUMMY_BASE_URL = "https://example.com";
+/**
+ *
+ * @throws {RequiredError}
+ * @export
+ */
+export declare const assertParamExists: (functionName: string, paramName: string, paramValue: unknown) => void;
+/**
+ *
+ * @export
+ */
+export declare const setApiKeyToObject: (object: any, keyParamName: string, configuration?: Configuration) => Promise<void>;
+/**
+ *
+ * @export
+ */
+export declare const setBasicAuthToObject: (object: any, configuration?: Configuration) => void;
+/**
+ *
+ * @export
+ */
+export declare const setBearerAuthToObject: (object: any, configuration?: Configuration) => Promise<void>;
+/**
+ *
+ * @export
+ */
+export declare const setOAuthToObject: (object: any, name: string, scopes: string[], configuration?: Configuration) => Promise<void>;
+/**
+ *
+ * @export
+ */
+export declare const setSearchParams: (url: URL, ...objects: any[]) => void;
+/**
+ *
+ * @export
+ */
+export declare const serializeDataIfNeeded: (value: any, requestOptions: any, configuration?: Configuration) => any;
+/**
+ *
+ * @export
+ */
+export declare const toPathString: (url: URL) => string;
+/**
+ *
+ * @export
+ */
+export declare const createRequestFunction: (axiosArgs: RequestArgs, globalAxios: AxiosInstance, BASE_PATH: string, configuration?: Configuration) => <T = unknown, R = AxiosResponse<T>>(axios?: AxiosInstance, basePath?: string) => Promise<R>;