@achs/env 3.1.0 → 3.1.1

package/src/providers/app-settings.provider.ts

@@ -1,67 +0,0 @@
-import chalk from 'chalk';
-import { CommandArguments } from '../arguments';
-import { EnvProvider } from '../interfaces';
-import { logger as globalLogger, readJson, writeJson } from '../utils';
-
-const KEY = 'app-settings';
-
-const logger = globalLogger.getChildLogger({
-    prefix: [chalk.bold.blue(`[${KEY}]`)]
-});
-
-const APP_SETTINGS_DEFAULT = {
-    '|DEFAULT|': {},
-    '|MODE|': {},
-    '|ENV|': {},
-    '|LOCAL|': {}
-};
-
-interface AppSettingsCommandArguments extends CommandArguments {
-    envFile: string;
-}
-
-/**
- * Loads config from appsettings.json.
- */
-export const AppSettingsProvider: EnvProvider<AppSettingsCommandArguments> = {
-    key: KEY,
-
-    builder: (builder) => {
-        builder.options({
-            envFile: {
-                group: KEY,
-                alias: 'ef',
-                type: 'string',
-                default: '[[root]]/appsettings.json',
-                describe: 'Environment variables file path (non secrets)'
-            }
-        });
-    },
-
-    load: async ({ env, modes = [], envFile, local }) => {
-        const [appsettings = APP_SETTINGS_DEFAULT, wasFound] = await readJson(
-            envFile
-        );
-
-        if (!wasFound) {
-            logger.warn(`${chalk.blue(envFile)} not found`);
-
-            logger.debug(`creating default ${chalk.blue(envFile)} file`);
-
-            await writeJson(envFile, APP_SETTINGS_DEFAULT);
-        }
-
-        // only load local in env load cmd
-        if (!local) appsettings['|LOCAL|'] = null;
-
-        return [
-            appsettings['|DEFAULT|'],
-
-            appsettings['|ENV|']?.[env],
-
-            ...modes.map((mode) => appsettings['|MODE|']?.[mode]),
-
-            appsettings['|LOCAL|']?.[env]
-        ];
-    }
-};

package/src/providers/azure-key-vault.provider.ts

@@ -1,277 +0,0 @@
-import chalk from 'chalk';
-import {
-    AzureKeyVault,
-    AzureKeyVaultSecrets,
-    createAzureKeyVaultMock
-} from '@achs/azure-key-vault';
-import { CommandArguments } from '../arguments';
-import { EnvProvider } from '../interfaces';
-import {
-    generateSchemaFrom,
-    logger as globalLogger,
-    readJson,
-    schemaToJson,
-    writeJson
-} from '../utils';
-import { Arguments } from 'yargs';
-import { existsSync } from 'fs';
-import { PullCommandArguments } from 'commands/pull.command';
-
-const KEY = 'azure-key-vault';
-
-const logger = globalLogger.getChildLogger({
-    prefix: [chalk.bold.blue(`[${KEY}]`)]
-});
-
-interface AzureKeyVaultCommandArguments extends CommandArguments {
-    secretsFile: string;
-    keysFile?: string[];
-    vaultUrl: string;
-    spn: string;
-    password: string;
-    tenant: string;
-    mock: boolean;
-}
-
-interface AzureKeyVaultCommandConfig {
-    [key: string]: {
-        vaultUrl: string;
-    };
-}
-
-/**
- * Loads secrets from env files in env/secrets
- * folder, loaded from Azure Key Vault.
- */
-export const AzureKeyVaultProvider: EnvProvider<
-    AzureKeyVaultCommandArguments & PullCommandArguments,
-    AzureKeyVaultCommandConfig
-> = {
-    key: KEY,
-
-    builder: (builder) => {
-        builder.options({
-            secretsFile: {
-                group: KEY,
-                type: 'string',
-                default: '[[root]]/[[env]].env.json',
-                describe: 'Secret variables file path'
-            },
-            keysFile: {
-                group: KEY,
-                alias: ['k', 'keys'],
-                type: 'array',
-                default: ['[[root]]/keys.json', '../keys.json'],
-                describe: 'Azure Key Vault keys file path'
-            },
-            vaultUrl: {
-                group: KEY,
-                alias: 'url',
-                type: 'string',
-                describe: 'Azure Key Vault URL'
-            },
-            spn: {
-                group: KEY,
-                alias: ['clientId', 'id'],
-                type: 'string',
-                describe: 'SPN Client ID'
-            },
-            password: {
-                group: KEY,
-                alias: ['p', 'pass', 'clientSecret'],
-                type: 'string',
-                describe: 'SPN Client Secret Password'
-            },
-            tenant: {
-                group: KEY,
-                alias: 't',
-                type: 'string',
-                describe: 'Azure Tenant ID'
-            },
-            mock: {
-                group: KEY,
-                type: 'boolean',
-                default: false,
-                describe: 'Mocks Azure Key Vault client'
-            }
-        });
-    },
-
-    push: async (argv, config) => {
-        const [secrets, secretsWasFound] = await readJson(argv.secretsFile);
-
-        if (!secretsWasFound) {
-            logger.error(`${chalk.blue(argv.secretFile)} not found`);
-
-            process.exit(1);
-        }
-
-        logger.silly('local secrets loaded:', secrets);
-        const akv = await loadAzureKeyVaultClient(
-            argv,
-            config?.[argv.env]?.vaultUrl
-        );
-        logger.info('pushing variables to store');
-        const results = await akv.setAll(secrets);
-        logger.silly('secrets pushed:', results);
-
-        const schema = await generateSchemaFrom(
-            [{ key: KEY, value: secrets }],
-            argv
-        );
-
-        logger.silly('schema for akv updated:', schema);
-    },
-
-    pull: async (argv, config) => {
-        const schema = argv.schema?.[KEY] as
-            | Record<string, unknown>
-            | undefined;
-
-        if (!schema) {
-            logger.error('no schema found');
-
-            process.exit(1);
-        }
-
-        const jsonTemplate = schemaToJson(schema) as Record<string, unknown>;
-
-        const akv = await loadAzureKeyVaultClient(
-            argv,
-            config?.[argv.env]?.vaultUrl
-        );
-
-        logger.info('pulling variables from store');
-
-        const secrets = await akv.getFor(
-            jsonTemplate as AzureKeyVaultSecrets,
-            true
-        );
-
-        logger.silly('remote secrets loaded:', secrets);
-
-        await writeJson(argv.secretsFile, secrets, argv.overwrite, true);
-    },
-
-    load: async (argv, config) => {
-        const { secretsFile } = argv;
-
-        if (!existsSync(secretsFile)) {
-            logger.warn('secrets file not found, pulling from store');
-
-            await AzureKeyVaultProvider.pull!(argv, config);
-        }
-
-        const [secrets] = await readJson(secretsFile);
-
-        return [secrets];
-    }
-};
-
-/**
- * Validate SPN credentials/keys.
- *
- * @param {(Record<string, any> | null)} keys
- *
- * @returns {boolean}
- */
-function keysAreValid(keys: Record<string, any> | null): boolean {
-    return keys && keys.clientId && keys.clientSecret && keys.tenantId;
-}
-
-/**
- * Loads SPN Azure Key Vault credentials from keys file.
- *
- * @param {string} env
- * @param {string[]} paths
- *
- * @returns {Record<string, string>} credentials
- */
-async function loadKeysFile(
-    env: string,
-    paths: string[]
-): Promise<Record<string, string>> {
-    logger.debug(`searching keys at ${chalk.yellow(paths.join(','))}`);
-
-    const readers = await Promise.all(paths.map((path) => readJson(path)));
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const [keys, wasFound] = readers.find(
-        ([keys, wasFound]) => wasFound && keysAreValid(keys[env])
-    ) ?? [null, false];
-
-    // if (!wasFound || !keys) {
-    //     logger.error(`no credentials found for ${chalk.green.underline(env)}`);
-    //     logger.warn(
-    //         'if you use Azure CLI, set "keysFile": null in your env.config file'
-    //     );
-
-    //     process.exit(1);
-    // }
-
-    return keys?.[env] ?? {};
-}
-
-/**
- * Loads credentials and initializes Azure Key Vault client.
- *
- * @param {Arguments<AzureKeyVaultCommandArguments>} argv command arguments
- *
- * @returns {*}  {Promise<AzureKeyVault>}
- */
-async function loadAzureKeyVaultClient(
-    {
-        env,
-        vaultUrl,
-        spn,
-        password,
-        tenant,
-        app,
-        keysFile,
-        mock
-    }: Arguments<AzureKeyVaultCommandArguments>,
-    configVaultUrl?: string
-): Promise<AzureKeyVault> {
-    let url = process.env.AZURE_VAULT_URL ?? vaultUrl ?? configVaultUrl;
-
-    const config = {
-        project: process.env.AZURE_PROJECT ?? (app?.project as string),
-        group: process.env.AZURE_GROUP ?? (app?.name as string),
-        env
-    };
-
-    if (!config.project) {
-        logger.error(
-            `no project info from ${chalk.blue('package.json')} found`
-        );
-
-        process.exit(1);
-    }
-
-    const credentials = {
-        clientId: process.env.AZURE_CLIENT_ID ?? spn,
-        clientSecret: process.env.AZURE_CLIENT_SECRET ?? password,
-        tenantId: process.env.AZURE_TENANT_ID ?? tenant
-    };
-
-    if (keysFile && keysFile.length > 0 && !keysAreValid(credentials)) {
-        const keys = await loadKeysFile(env, keysFile);
-
-        url ??= keys.vaultUrl;
-        credentials.clientId ??= keys.clientId;
-        credentials.clientSecret ??= keys.clientSecret;
-        credentials.tenantId ??= keys.tenantId;
-    }
-
-    logger.debug(
-        `credentials loaded for project ${chalk.bold.underline.yellowBright(
-            config.project
-        )} and group ${chalk.bold.underline.yellowBright(config.group)}`
-    );
-
-    logger.debug(`connected to ${chalk.bold.underline.greenBright(url)}`);
-
-    return mock
-        ? createAzureKeyVaultMock(config)
-        : new AzureKeyVault(url, config, credentials);
-}

package/src/providers/index.ts

@@ -1,29 +0,0 @@
-import { EnvProvider } from '../interfaces';
-import { AppSettingsProvider } from './app-settings.provider';
-import { PackageJsonProvider } from './package-json.provider';
-import { AzureKeyVaultProvider } from './azure-key-vault.provider';
-import { LocalProvider } from './local.provider';
-
-const IntegratedProviders: Record<string, EnvProvider<any, any>> = {
-    [PackageJsonProvider.key]: PackageJsonProvider,
-    [AppSettingsProvider.key]: AppSettingsProvider,
-    [AzureKeyVaultProvider.key]: AzureKeyVaultProvider,
-    [LocalProvider.key]: LocalProvider
-};
-
-const IntegratedProviderConfig = [
-    {
-        path: PackageJsonProvider.key
-    },
-    {
-        path: AppSettingsProvider.key
-    },
-    {
-        path: AzureKeyVaultProvider.key
-    },
-    {
-        path: LocalProvider.key
-    }
-];
-
-export { IntegratedProviders, IntegratedProviderConfig };

package/src/providers/local.provider.ts

@@ -1,44 +0,0 @@
-import { existsSync } from 'fs';
-import { CommandArguments } from '../arguments';
-import { EnvProvider } from '../interfaces';
-import { readJson, writeJson } from '../utils';
-
-const KEY = 'local';
-
-interface LocalCommandArguments extends CommandArguments {
-    localFile: string;
-}
-
-/**
- * Loads local variables from env files in env folder.
- */
-export const LocalProvider: EnvProvider<LocalCommandArguments> = {
-    key: KEY,
-
-    builder: (builder) => {
-        builder.options({
-            localFile: {
-                group: KEY,
-                alias: 'lf',
-                type: 'string',
-                default: '[[root]]/[[env]].local.env.json',
-                describe: 'Local secret variables file path'
-            }
-        });
-    },
-
-    load: async ({ localFile, ci }) => {
-        // ci mode doesn't load local vars
-        if (ci) return [];
-
-        if (!existsSync(localFile)) {
-            await writeJson(localFile, {});
-
-            return [];
-        }
-
-        const [vars] = await readJson(localFile);
-
-        return [vars];
-    }
-};

package/src/providers/package-json.provider.ts

@@ -1,39 +0,0 @@
-import { CommandArguments } from '../arguments';
-import { EnvProvider } from '../interfaces';
-
-const KEY = 'package-json';
-
-interface PackageJsonCommandArguments extends CommandArguments {
-    varPrefix: string;
-}
-
-/**
- * Loads project info from package.json.
- */
-export const PackageJsonProvider: EnvProvider<PackageJsonCommandArguments> = {
-    key: KEY,
-
-    builder: (builder) => {
-        builder.options({
-            varPrefix: {
-                group: KEY,
-                alias: 'vp',
-                type: 'string',
-                default: '',
-                describe: 'Prefix for loaded variables'
-            }
-        });
-    },
-
-    load: ({ env, app, varPrefix }) => {
-        return {
-            [`${varPrefix}ENV`]: env,
-
-            [`${varPrefix}VERSION`]: app?.version,
-            [`${varPrefix}PROJECT`]: app?.project,
-            [`${varPrefix}NAME`]: app?.name,
-            [`${varPrefix}TITLE`]: app?.title,
-            [`${varPrefix}DESCRIPTION`]: app?.description
-        };
-    }
-};

package/src/utils/command.util.ts

@@ -1,223 +0,0 @@
-import chalk from 'chalk';
-import merge from 'merge-deep';
-import { Arguments } from 'yargs';
-import { CommandArguments } from 'arguments';
-import { EnvCommandArguments } from 'commands/env.command';
-import { EnvProviderConfig, EnvProviderResult } from '../interfaces';
-import {
-    createValidators,
-    interpolate,
-    logger,
-    readJson,
-    schemaFrom,
-    writeJson
-} from '../utils';
-
-/**
- * Injects config to command arguments from file.
- *
- * @param {Record<string, unknown>} argv
- * @param {[string, string]} delimiters
- */
-export async function loadConfigFile(
-    argv: Record<string, unknown>,
-    delimiters: [string, string]
-): Promise<void> {
-    if (typeof argv.configFile === 'string') {
-        const path = interpolate(argv.configFile, argv, delimiters);
-        const [config, success] = await readJson(path);
-
-        if (success) for (const key in config) argv[key] ??= config[key];
-    }
-}
-
-/**
- * Extracts subcommand from command line parameters.
- *
- * @export
- * @param {string[]} rawArgv process.argv.slice(2)
- * @param {[string, string]} delimiters
- *
- * @returns {string[]} subcommand for wrap if exists
- */
-export function getSubcommand(rawArgv: string[], delimiters: [string, string]) {
-    let subcommand: string[] = [];
-
-    // subcommand delimiter indexes
-    const begin = rawArgv.indexOf(delimiters[0]);
-    const count = rawArgv.lastIndexOf(delimiters[1]) - begin;
-
-    // calculates subcommand surrounded by delimiters
-    if (begin > 0) {
-        subcommand =
-            count > 0
-                ? rawArgv.splice(begin, count + 1).slice(1, -1)
-                : rawArgv.splice(begin).slice(1);
-    }
-
-    return subcommand;
-}
-
-/**
- * Loads providers JSON schema from file.
- *
- * @param {Record<string, unknown>} argv
- * @param {[string, string]} delimiters
- *
- * @returns {Promise<Record<string, unknown>>}
- */
-export async function loadSchemaFile(
-    argv: Record<string, unknown>,
-    delimiters: [string, string]
-): Promise<Record<string, unknown> | undefined> {
-    if (typeof argv.schemaFile === 'string') {
-        const path = interpolate(argv.schemaFile, argv, delimiters);
-        const [schema, success] = await readJson(path);
-
-        return success ? schema : undefined;
-    }
-
-    return undefined;
-}
-
-/**
- * Reads project package.json.
- *
- * @export
- * @returns {Promise<Record<string, unknown>> | never}
- */
-export async function loadProjectInfo(): Promise<
-    Record<string, unknown> | undefined
-> {
-    try {
-        return await import(`${process.cwd()}/package.json`);
-    } catch {
-        logger.warn(
-            `project file ${chalk.underline.yellow('package.json')} not found`
-        );
-
-        return undefined;
-    }
-}
-
-/**
- * Executes load functions from provider handlers.
- *
- * @param {EnvProviderConfig[]} providers
- * @param {Partial<Arguments<EnvCommandArguments>>} argv
- *
- * @returns {EnvProviderResult[]}
- */
-export function loadVariablesFromProviders(
-    providers: EnvProviderConfig[],
-    argv: Partial<Arguments<EnvCommandArguments>>
-): Promise<EnvProviderResult[]> {
-    if (!providers) return Promise.resolve([]) as Promise<EnvProviderResult[]>;
-
-    return Promise.all(
-        providers.map(({ handler: { key, load }, config }) => {
-            logger.silly(`executing ${chalk.yellow(key)} provider`);
-
-            const value = load(argv, config);
-
-            if (value instanceof Promise) {
-                return value.then((value) => ({
-                    key,
-                    config,
-                    value
-                }));
-            } else {
-                return { key, config, value };
-            }
-        })
-    );
-}
-
-/**
- * Flattern environment provider results.
- *
- * @param {EnvProviderResult[]} results
- * @param {Partial<Arguments<EnvCommandArguments>>} argv
- *
- * @throws {Error} on schema validation failed
- *
- * @returns {EnvProviderResult[]} flatten results
- */
-export function flatResults(
-    results: EnvProviderResult[]
-): EnvProviderResult[] | never {
-    return results.flatMap(({ value }) => {
-        if (Array.isArray(value)) value = merge({}, ...value);
-
-        return value;
-    });
-}
-
-/**
- * Flattern and validates environment provider results.
- *
- * @param {EnvProviderResult[]} results
- * @param {Partial<Arguments<EnvCommandArguments>>} argv
- *
- * @throws {Error} on schema validation failed
- *
- * @returns {EnvProviderResult[]}
- */
-export function flatAndValidateResults(
-    results: EnvProviderResult[],
-    argv: Partial<Arguments<EnvCommandArguments>>
-): EnvProviderResult[] | never {
-    if (!argv.schemaValidate) return flatResults(results);
-
-    const validators = createValidators(argv.schema!, argv.detectFormat);
-
-    return results.flatMap(({ key, value }) => {
-        if (Array.isArray(value)) value = merge({}, ...value);
-
-        const validator = validators![key];
-
-        if (validator(value)) return value;
-
-        logger.error(
-            `schema validation failed for ${chalk.yellow(key)}`,
-            validator.errors
-        );
-
-        throw new Error(`schema validation failed for ${key}`);
-    });
-}
-
-/**
- * Creates or updates JSON schema from
- * environment variables grouped by provider key.
- *
- * @export
- * @param {EnvProviderResult[]} env
- * @param {Arguments<EnvCommandArguments>} argv
- *
- * @returns {Promise<object>} JSON schema grouped by provider key.
- */
-export async function generateSchemaFrom(
-    env: EnvProviderResult[],
-    argv: Arguments<CommandArguments>
-): Promise<object> {
-    const { resolve, nullable, detectFormat, schemaFile } = argv;
-
-    // generates schemas from proviers results
-    let schema = env.reduce((schema, { key, value }) => {
-        const env = Array.isArray(value) ? merge({}, ...value) : value;
-
-        schema[key] = schemaFrom(env, {
-            nullable,
-            strings: { detectFormat }
-        });
-
-        return schema;
-    }, {} as Record<string, unknown>);
-
-    if (resolve === 'merge') schema = merge(argv.schema, schema);
-
-    await writeJson(schemaFile, schema, true);
-
-    return schema;
-}