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

Zephyr plugin agent

import "node:module";
import axios from "axios";
import { ZE_API_ENDPOINT, assertZephyrBuildTarget, ze_api_gateway } from "zephyr-edge-contract";
import { ZeErrors, ZephyrError } from "../lib/errors/index.mjs";
import { parseUrl } from "../lib/http/http-request.mjs";
import { ze_log } from "../lib/logging/index.mjs";
import { getToken } from "../lib/node-persist/token.mjs";
async function resolve_remote_dependency(params) {
    if (void 0 !== params.platform) assertZephyrBuildTarget(params.platform, 'resolve_remote_dependency({ platform })');
    try {
        return await request_remote_dependency(params);
    } catch (cause) {
        if (params.version.startsWith('workspace:')) {
            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 = ZE_API_ENDPOINT() + `${ze_api_gateway.resolve}/` + `${encodeURIComponent(application_uid)}/` + `${encodeURIComponent(version)}`;
    const resolveDependency = 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 {
        ze_log.remotes('URL for resolving dependency:', resolveDependency.toString());
        const token = await getToken();
        const res = await axios.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 ZephyrError(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) {
            ze_log.remotes('resolved dependency:', response.value, 'application_uid: ', application_uid, 'version: ', version);
            return Object.assign({}, response.value, {
                version,
                platform
            });
        }
        throw new ZephyrError(ZeErrors.ERR_RESOLVE_REMOTES, {
            appUid: application_uid,
            appName,
            projectName,
            orgName,
            version,
            data: {
                response
            }
        });
    } catch (cause) {
        if (cause instanceof ZephyrError) throw cause;
        throw new ZephyrError(ZeErrors.ERR_CANNOT_RESOLVE_APP_NAME_WITH_VERSION, {
            version,
            cause
        });
    }
}
export { resolve_remote_dependency };

//# sourceMappingURL=resolve_remote_dependency.mjs.map