zephyr-agent/dist/lib/build-context/ze-util-read-package-json.mjs

Zephyr plugin agent

import "node:module";
import node_fs from "node:fs";
import { resolve } from "node:path";
import { safe_json_parse } from "zephyr-edge-contract";
import { ZeErrors, ZephyrError } from "../errors/index.mjs";
import { ze_log } from "../logging/index.mjs";
import { logFn } from "../logging/ze-log-event.mjs";
import { find_nearest_package_json } from "./find-nearest-package-json.mjs";
import { parseZeDependencies } from "./ze-util-parse-ze-dependencies.mjs";
import { getZephyrConfig, mergeRemoteDependencies } from "./zephyr-config.mjs";
const DEFAULT_PACKAGE_VERSION = '0.0.0';
async function getPackageJson(context, zephyrConfig = getZephyrConfig(context)) {
    let startingPath;
    try {
        startingPath = context || process.cwd();
        if (startingPath && node_fs.statSync(startingPath).isFile()) startingPath = resolve(startingPath, '..');
        ze_log["package"]('getPackageJson searching from path', startingPath);
    } catch (error) {
        throw new ZephyrError(ZeErrors.ERR_PACKAGE_JSON_NOT_FOUND, `Invalid starting path: ${context}. Error: ${error}`);
    }
    let nearest_package_json;
    try {
        nearest_package_json = await find_nearest_package_json(startingPath);
        if (!nearest_package_json) throw new ZephyrError(ZeErrors.ERR_PACKAGE_JSON_NOT_FOUND, `No package.json found starting from: ${startingPath}`);
        ze_log["package"]('Found package.json at', nearest_package_json.path);
    } catch (error) {
        if (error instanceof ZephyrError) throw error;
        throw new ZephyrError(ZeErrors.ERR_PACKAGE_JSON_NOT_FOUND, `Error finding package.json from path: ${startingPath}. Error: ${error}`);
    }
    try {
        const { json, path: packageJsonPath } = nearest_package_json;
        const parsed_package_json = safe_json_parse(json);
        if (!parsed_package_json) throw new ZephyrError(ZeErrors.ERR_PACKAGE_JSON_NOT_VALID, `Invalid JSON in package.json at: ${packageJsonPath}`);
        if (!parsed_package_json.name) throw new ZephyrError(ZeErrors.ERR_PACKAGE_JSON_MUST_HAVE_NAME, {
            path: packageJsonPath,
            data: {
                path: packageJsonPath
            }
        });
        if (!parsed_package_json.version) {
            parsed_package_json.version = DEFAULT_PACKAGE_VERSION;
            const warning = new ZephyrError(ZeErrors.ERR_PACKAGE_JSON_MISSING_VERSION, {
                path: packageJsonPath,
                defaultVersion: DEFAULT_PACKAGE_VERSION,
                data: {
                    path: packageJsonPath,
                    defaultVersion: DEFAULT_PACKAGE_VERSION
                }
            });
            logFn('warn', `${warning.code}: ${warning.message}`);
        }
        const zephyr_dependencies = mergeRemoteDependencies(parsed_package_json['zephyr:dependencies'], zephyrConfig);
        if (zephyr_dependencies) parsed_package_json.zephyrDependencies = parseZeDependencies(zephyr_dependencies);
        else {
            logFn('info', 'No zephyr:dependencies found in package.json, to give you more control over your dependencies, check out our documentation:');
            logFn('info', 'https://docs.zephyr-cloud.io/features/remote-dependencies');
        }
        ze_log["package"]('Successfully parsed package.json', {
            name: parsed_package_json.name,
            version: parsed_package_json.version,
            path: packageJsonPath
        });
        return parsed_package_json;
    } catch (error) {
        if (error instanceof ZephyrError) throw error;
        throw new ZephyrError(ZeErrors.ERR_PACKAGE_JSON_NOT_VALID, `Error processing package.json: ${error}`);
    }
}
export { getPackageJson };

//# sourceMappingURL=ze-util-read-package-json.mjs.map