@stolostron/multicluster-sdk/lib/internal/apiRequests.js

Provides extensions and APIs that dynamic plugins can use to leverage multicluster capabilities provided by Red Hat Advanced Cluster Management.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.fleetWatch = exports.buildResourceURL = exports.getResourcePath = void 0;
exports.getClusterFromOptions = getClusterFromOptions;
exports.getNamespaceFromOptions = getNamespaceFromOptions;
exports.getNameFromOptions = getNameFromOptions;
exports.getOptionsWithoutCluster = getOptionsWithoutCluster;
exports.getResourceURLFromOptions = getResourceURLFromOptions;
const constants_1 = require("../internal/constants");
const getFleetK8sAPIPath_1 = require("../api/getFleetK8sAPIPath");
const requirements_1 = require("./requirements");
const isFleetK8sAPIOptionsWithData = (options) => {
    const data = options.data;
    return typeof data === 'object' && !Array.isArray(data);
};
const isFleetK8sAPIOptionsWithResource = (options) => {
    const resource = options.resource;
    return typeof resource === 'object' && !Array.isArray(resource);
};
const getK8sAPIPath = ({ apiGroup = 'core', apiVersion }) => {
    const isLegacy = apiGroup === 'core' && apiVersion === 'v1';
    let p = isLegacy ? '/api/' : '/apis/';
    if (!isLegacy && apiGroup) {
        p += `${apiGroup}/`;
    }
    p += apiVersion;
    return p;
};
const excludeEmptyQueryParams = (queryParams) => Object.fromEntries(Object.entries(queryParams || {}).filter(([, value]) => value !== undefined && value !== null && value !== ''));
const getResourcePath = (options) => {
    let url = getK8sAPIPath(options.model);
    if (options.ns) {
        url += `/namespaces/${options.ns}`;
    }
    url += `/${options.model.plural}`;
    if (options.name) {
        // Some resources like Users can have special characters in the name.
        url += `/${encodeURIComponent(options.name)}`;
    }
    if (options.path) {
        url += `/${options.path}`;
    }
    const queryParams = excludeEmptyQueryParams(options.queryParams || {});
    if (Object.keys(queryParams).length > 0) {
        const queryString = new URLSearchParams(queryParams).toString();
        url += `?${queryString}`;
    }
    return url;
};
exports.getResourcePath = getResourcePath;
const buildResourceURL = (params) => {
    const { model, ns, name, cluster, queryParams, basePath = constants_1.BASE_K8S_API_PATH } = params;
    const resourcePath = (0, exports.getResourcePath)({ model, ns, name, queryParams, cluster });
    return `${basePath}${resourcePath}`;
};
exports.buildResourceURL = buildResourceURL;
function getClusterFromOptions(options) {
    return (options.cluster ??
        ((isFleetK8sAPIOptionsWithData(options) && options.data.cluster) ||
            (isFleetK8sAPIOptionsWithResource(options) && options.resource.cluster) ||
            undefined));
}
function getNamespaceFromOptions(options) {
    return (options.ns ??
        ((isFleetK8sAPIOptionsWithData(options) && options.data.metadata?.namespace) ||
            (isFleetK8sAPIOptionsWithResource(options) && options.resource.metadata?.namespace) ||
            options.queryParams?.ns ||
            undefined));
}
function getNameFromOptions(options) {
    return (options.name ??
        ((isFleetK8sAPIOptionsWithData(options) && options.data.metadata?.name) ||
            (isFleetK8sAPIOptionsWithResource(options) && options.resource.metadata?.name) ||
            undefined));
}
function getOptionsWithoutCluster(options) {
    const { cluster: _optionsCluster, ...optionsWithoutCluster } = options;
    if (isFleetK8sAPIOptionsWithData(options)) {
        const { cluster: _dataCluster, ...dataWithoutCluster } = options.data;
        return { ...optionsWithoutCluster, data: dataWithoutCluster };
    }
    else if (isFleetK8sAPIOptionsWithResource(options)) {
        const { cluster: _resourceCluster, ...resourceWithoutCluster } = options.resource;
        return { ...optionsWithoutCluster, resource: resourceWithoutCluster };
    }
    return optionsWithoutCluster;
}
async function getResourceURLFromOptions(options, collection = false) {
    const basePath = await (0, getFleetK8sAPIPath_1.getFleetK8sAPIPath)(getClusterFromOptions(options));
    return (0, exports.buildResourceURL)({
        basePath,
        ...options,
        cluster: getClusterFromOptions(options),
        ns: getNamespaceFromOptions(options),
        name: collection ? undefined : getNameFromOptions(options),
    });
}
const fleetWatch = (model, query = {}, backendURL) => {
    const queryParams = { watch: 'true' };
    const { labelSelector } = query;
    if (labelSelector) {
        const encodedSelector = (0, requirements_1.selectorToString)(labelSelector);
        if (encodedSelector) {
            queryParams.labelSelector = encodedSelector;
        }
    }
    if (query.fieldSelector) {
        queryParams.fieldSelector = query.fieldSelector;
    }
    if (query.resourceVersion) {
        queryParams.resourceVersion = query.resourceVersion;
    }
    if (query.allowWatchBookmarks) {
        queryParams.allowWatchBookmarks = 'true';
    }
    const requestPath = (0, exports.buildResourceURL)({
        model,
        cluster: query.cluster,
        queryParams,
        ns: query.ns,
        basePath: backendURL,
    });
    return new WebSocket(requestPath);
};
exports.fleetWatch = fleetWatch;
//# sourceMappingURL=apiRequests.js.map