95 lines
3.5 KiB
TypeScript
95 lines
3.5 KiB
TypeScript
import { Environment, NonSecretEnvironment } from "@hoppscotch/data";
|
|
import { entityReference } from "verzod";
|
|
import { z } from "zod";
|
|
|
|
import { TestCmdEnvironmentOptions } from "../../types/commands";
|
|
import { error } from "../../types/errors";
|
|
import {
|
|
HoppEnvKeyPairObject,
|
|
HoppEnvPair,
|
|
HoppEnvs,
|
|
} from "../../types/request";
|
|
import { getResourceContents } from "../../utils/getters";
|
|
|
|
/**
|
|
* Parses environment data from a given path or ID and returns the data conforming to the latest version of the `Environment` schema.
|
|
*
|
|
* @param {TestCmdEnvironmentOptions} options Supplied values for CLI flags.
|
|
* @param {string} options.env Path of the environment `.json` file to be parsed.
|
|
* @param {string} [options.token] Personal access token to fetch workspace environments.
|
|
* @param {string} [options.server] server URL for SH instance.
|
|
* @returns {Promise<HoppEnvs>} A promise that resolves to the parsed environment object with global and selected environments.
|
|
*/
|
|
export async function parseEnvsData(options: TestCmdEnvironmentOptions) {
|
|
const { env: pathOrId, token: accessToken, server: serverUrl } = options;
|
|
|
|
const contents = await getResourceContents({
|
|
pathOrId,
|
|
accessToken,
|
|
serverUrl,
|
|
resourceType: "environment",
|
|
});
|
|
|
|
const envPairs: Array<HoppEnvPair | Record<string, string>> = [];
|
|
|
|
// The legacy key-value pair format that is still supported
|
|
const HoppEnvKeyPairResult = HoppEnvKeyPairObject.safeParse(contents);
|
|
|
|
// Shape of the single environment export object that is exported from the app
|
|
const HoppEnvExportObjectResult = Environment.safeParse(contents);
|
|
|
|
// Shape of the bulk environment export object that is exported from the app
|
|
const HoppBulkEnvExportObjectResult = z
|
|
.array(entityReference(Environment))
|
|
.safeParse(contents);
|
|
|
|
// CLI doesnt support bulk environments export
|
|
// Hence we check for this case and throw an error if it matches the format
|
|
if (HoppBulkEnvExportObjectResult.success) {
|
|
throw error({ code: "BULK_ENV_FILE", path: pathOrId, data: error });
|
|
}
|
|
|
|
// Checks if the environment file is of the correct format
|
|
// If it doesnt match either of them, we throw an error
|
|
if (
|
|
!HoppEnvKeyPairResult.success &&
|
|
HoppEnvExportObjectResult.type === "err"
|
|
) {
|
|
throw error({ code: "MALFORMED_ENV_FILE", path: pathOrId, data: error });
|
|
}
|
|
|
|
if (HoppEnvKeyPairResult.success) {
|
|
for (const [key, value] of Object.entries(HoppEnvKeyPairResult.data)) {
|
|
envPairs.push({
|
|
key,
|
|
initialValue: value,
|
|
currentValue: value,
|
|
secret: false,
|
|
});
|
|
}
|
|
} else if (HoppEnvExportObjectResult.type === "ok") {
|
|
// Original environment variables from the supplied export file
|
|
const originalEnvVariables = (contents as Environment).variables;
|
|
|
|
// Above environment variables conforming to the latest schema
|
|
// `value` fields if specified will be omitted for secret environment variables
|
|
const migratedEnvVariables = HoppEnvExportObjectResult.value.variables;
|
|
|
|
// The values supplied for secret environment variables have to be considered in the CLI
|
|
// For each secret environment variable, include the value in case supplied
|
|
const resolvedEnvVariables = migratedEnvVariables.map((variable, idx) => {
|
|
if (variable.secret && originalEnvVariables[idx].initialValue) {
|
|
return {
|
|
...variable,
|
|
initialValue: originalEnvVariables[idx].initialValue,
|
|
};
|
|
}
|
|
|
|
return variable;
|
|
});
|
|
|
|
envPairs.push(...resolvedEnvVariables);
|
|
}
|
|
|
|
return <HoppEnvs>{ global: [], selected: envPairs };
|
|
}
|