zephyr-agent/dist/zephyr-engine/resolve_remote_dependency.js

Zephyr plugin agent

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.n = (module)=>{
        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
        __webpack_require__.d(getter, {
            a: getter
        });
        return getter;
    };
})();
(()=>{
    __webpack_require__.d = (exports1, getters, values)=>{
        var define = (defs, kind)=>{
            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
                enumerable: true,
                [kind]: defs[key]
            });
        };
        define(getters, "get");
        define(values, "value");
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    resolve_remote_dependency: ()=>resolve_remote_dependency
});
const external_axios_namespaceObject = require("axios");
var external_axios_default = /*#__PURE__*/ __webpack_require__.n(external_axios_namespaceObject);
const external_zephyr_edge_contract_namespaceObject = require("zephyr-edge-contract");
const index_js_namespaceObject = require("../lib/errors/index.js");
const http_request_js_namespaceObject = require("../lib/http/http-request.js");
const logging_index_js_namespaceObject = require("../lib/logging/index.js");
const token_js_namespaceObject = require("../lib/node-persist/token.js");
async function resolve_remote_dependency(params) {
    if (void 0 !== params.platform) (0, external_zephyr_edge_contract_namespaceObject.assertZephyrBuildTarget)(params.platform, 'resolve_remote_dependency({ platform })');
    try {
        return await request_remote_dependency(params);
    } catch (cause) {
        if (params.version.startsWith('workspace:')) {
            logging_index_js_namespaceObject.ze_log.remotes(`No workspace build found for ${params.application_uid}@${params.version}; falling back to the latest published version`);
            return request_remote_dependency({
                ...params,
                version: '*'
            });
        }
        throw cause;
    }
}
async function request_remote_dependency({ application_uid, version, platform, build_context, dependencyUrlMode }) {
    const depUrl = (0, external_zephyr_edge_contract_namespaceObject.ZE_API_ENDPOINT)() + `${external_zephyr_edge_contract_namespaceObject.ze_api_gateway.resolve}/` + `${encodeURIComponent(application_uid)}/` + `${encodeURIComponent(version)}`;
    const resolveDependency = (0, http_request_js_namespaceObject.parseUrl)(depUrl);
    if (platform) resolveDependency.searchParams.append('build_target', platform);
    if (build_context) resolveDependency.searchParams.append('build_context', build_context);
    if (dependencyUrlMode) resolveDependency.searchParams.append('url_mode', dependencyUrlMode);
    try {
        logging_index_js_namespaceObject.ze_log.remotes('URL for resolving dependency:', resolveDependency.toString());
        const token = await (0, token_js_namespaceObject.getToken)();
        const res = await external_axios_default().get(resolveDependency.toString(), {
            headers: {
                'Content-Type': 'application/json',
                Authorization: `Bearer ${token}`,
                Accept: 'application/json'
            }
        });
        const [appName, projectName, orgName] = application_uid.split('.');
        if (res.status < 200 || res.status >= 300) throw new index_js_namespaceObject.ZephyrError(index_js_namespaceObject.ZeErrors.ERR_RESOLVE_REMOTES, {
            appUid: application_uid,
            appName,
            projectName,
            orgName,
            version,
            data: {
                url: resolveDependency.toString(),
                error: res.data
            }
        });
        const response = res.data;
        if (response.value) {
            logging_index_js_namespaceObject.ze_log.remotes('resolved dependency:', response.value, 'application_uid: ', application_uid, 'version: ', version);
            return Object.assign({}, response.value, {
                version,
                platform
            });
        }
        throw new index_js_namespaceObject.ZephyrError(index_js_namespaceObject.ZeErrors.ERR_RESOLVE_REMOTES, {
            appUid: application_uid,
            appName,
            projectName,
            orgName,
            version,
            data: {
                response
            }
        });
    } catch (cause) {
        if (cause instanceof index_js_namespaceObject.ZephyrError) throw cause;
        throw new index_js_namespaceObject.ZephyrError(index_js_namespaceObject.ZeErrors.ERR_CANNOT_RESOLVE_APP_NAME_WITH_VERSION, {
            version,
            cause
        });
    }
}
exports.resolve_remote_dependency = __webpack_exports__.resolve_remote_dependency;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "resolve_remote_dependency"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=resolve_remote_dependency.js.map