@achs/env 3.1.0 → 3.1.1

package/src/commands/env.command.ts

@@ -1,139 +0,0 @@
-import chalk from 'chalk';
-import merge from 'merge-deep';
-import { spawn } from 'child_process';
-import { CommandModule } from 'yargs';
-import { CommandArguments } from '../arguments';
-import {
-    createValidator,
-    flatAndValidateResults,
-    flatResults,
-    flatSchema,
-    flatten,
-    interpolate,
-    loadVariablesFromProviders,
-    logger,
-    normalize
-} from '../utils';
-
-export interface EnvCommandArguments extends CommandArguments {
-    // Command for execute after inject environment variables.
-    // Should be prefixed or surrounded by ':' character.
-    subcmd: string[];
-    // whether validate schema before injecting variables
-    schemaValidate: boolean;
-}
-
-/**
- * Main command.
- * Injects environment variables into process.env.
- *
- * @example [>_]: env -e dev -m debug : npm start
- */
-export const envCommand: CommandModule<any, EnvCommandArguments> = {
-    command: '$0 [options..] [: <subcmd> :]',
-    describe: 'Inject environment variables into process',
-    builder: (builder) => {
-        builder
-            .options({
-                subcmd: {
-                    type: 'array',
-                    describe: 'Command for inject environment variables'
-                },
-                schemaValidate: {
-                    alias: 'validate',
-                    type: 'boolean',
-                    default: true,
-                    describe: 'Whether validates variables using JSON schema'
-                }
-            })
-            .example(
-                'env -e dev -m test unit : npm test',
-                'Loads "dev" environment variables, in "test" and "unit" modes, for "npm start" command'
-            )
-            .example(
-                'env -e dev -m debug : npm start : -c my-config.json',
-                'Loads "dev" environment variables, in "debug" mode, for "npm test" command and custom config file'
-            )
-            .example(
-                'env -e dev -m debug -c [[root]]/[[env]].env.json : npm start',
-                'Loads custom config file placed in root folder and named same as the env'
-            )
-            .check((argv): boolean => {
-                // special check for custom argument
-                if (argv._.length === 0 && !argv.subcmd) {
-                    logger.error(
-                        'No one subcommand provided for exec surrounded by :'
-                    );
-
-                    process.exit(1);
-                }
-
-                return true;
-            });
-
-        return builder;
-    },
-    handler: async ({ providers, schemaValidate, expand, ...argv }) => {
-        const results = await loadVariablesFromProviders(providers, argv);
-
-        let env = merge({ NODE_ENV: 'development' }, ...flatResults(results));
-        env = flatten(env, argv.nestingDelimiter);
-
-        if (schemaValidate) {
-            let schema = {};
-
-            for (const {
-                handler: { key }
-            } of providers) {
-                const providerSchema = argv.schema?.[key];
-
-                if (providerSchema) {
-                    schema = Object.assign(
-                        schema,
-                        flatSchema(providerSchema, '', argv.nestingDelimiter)
-                    );
-                }
-            }
-
-            const validator = createValidator({
-                type: 'object',
-                properties: schema
-            });
-
-            if (!validator(env)) {
-                logger.error('schema validation failed', validator.errors);
-
-                process.exit(1);
-            }
-        }
-
-        env = normalize(env, argv.nestingDelimiter, argv.arrayDescomposition);
-        if (expand) env = interpolate(env, env);
-
-        logger.debug('environment loaded:', env);
-
-        // loads env vars to process.env
-        process.env = {
-            ...process.env,
-            ...env
-        };
-
-        logger.info(
-            'executing command >',
-            chalk.bold.yellow(argv.subcmd.join(' '))
-        );
-
-        spawn(argv.subcmd[0], argv.subcmd.slice(1), {
-            stdio: 'inherit',
-            shell: true
-        }).on('exit', (code) => {
-            if (code === 0) {
-                logger.info('process finished successfully');
-            } else {
-                logger.error('process finished with error');
-
-                process.exit(1);
-            }
-        });
-    }
-};

package/src/commands/export.command.ts

@@ -1,88 +0,0 @@
-import merge from 'merge-deep';
-import { CommandModule } from 'yargs';
-import { CommandArguments } from '../arguments';
-import {
-    flatAndValidateResults,
-    flatten,
-    interpolate,
-    loadVariablesFromProviders,
-    logger,
-    normalize,
-    writeEnvFromJson,
-    writeJson
-} from '../utils';
-
-export interface ExportCommandArguments extends CommandArguments {
-    format: 'json' | 'dotenv';
-
-    uri: string;
-}
-
-/**
- * Export command.
- * Export environment variables to a file.
- *
- * @example [>_]: env export -e dev -m build
- */
-export const exportCommand: CommandModule<any, ExportCommandArguments> = {
-    command: 'export [options..]',
-    describe: 'Export unified environment variables to a file from providers',
-    builder: (builder) => {
-        builder
-            .options({
-                uri: {
-                    alias: ['u', 'p', 'path'],
-                    type: 'string',
-                    default: '.env',
-                    describe: 'Uri for export file with variables'
-                },
-                format: {
-                    alias: 'f',
-                    type: 'string',
-                    default: 'dotenv',
-                    choices: ['json', 'dotenv'],
-                    describe: 'Format for export variables'
-                }
-            })
-            .example(
-                'env export -e dev -m build',
-                'Exports "dev" variables to a dotenv file at root as ".env"'
-            )
-            .example(
-                'env export -e prod -m build -f json --uri [[env]].env.json',
-                'Exports "prod" variables to a json file at root as "prod.env.json"'
-            );
-
-        return builder;
-    },
-    handler: async ({ providers, expand, ...argv }) => {
-        const results = await loadVariablesFromProviders(providers, argv);
-
-        let env = merge(
-            { NODE_ENV: 'development' },
-            ...flatAndValidateResults(results, argv)
-        );
-
-        // results normalization merging
-        env = flatten(env, argv.nestingDelimiter);
-        env = normalize(env, argv.nestingDelimiter, argv.arrayDescomposition);
-        if (expand) env = interpolate(env, env);
-
-        logger.debug('environment loaded:', env);
-
-        const { format, uri } = argv;
-
-        switch (format) {
-            case 'dotenv':
-                await writeEnvFromJson(uri, env, true);
-                break;
-
-            case 'json':
-                await writeJson(uri, env, true);
-                break;
-
-            default:
-                logger.error(`format ${format} not recognized`);
-        }
-    }
-};

package/src/commands/pull.command.ts

@@ -1,52 +0,0 @@
-import chalk from 'chalk';
-import { CommandModule } from 'yargs';
-import { CommandArguments } from '../arguments';
-import { logger } from '../utils';
-
-export interface PullCommandArguments extends CommandArguments {
-    // whether variables should be overwritten in already exists
-    overwrite: boolean;
-}
-
-/**
- * Pulls environment variables from providers.
- *
- * @example [>_]: env pull -e dev
- */
-export const pullCommand: CommandModule<any, PullCommandArguments> = {
-    command: 'pull [options..]',
-    describe: 'Pulls environment variables from providers',
-    builder: (builder) => {
-        builder
-            .options({
-                overwrite: {
-                    alias: 'o',
-                    type: 'boolean',
-                    default: false,
-                    describe: 'Overwrite local variables'
-                }
-            })
-            .example('env pull -e dev', 'Download "dev" environment secrets')
-            .example(
-                'env pull -e dev -o',
-                'Download and overwrite (if any exists) "dev" environment secrets'
-            );
-
-        return builder;
-    },
-    handler: async ({ providers, ...argv }) => {
-        const promises = await Promise.all(
-            providers
-                .filter(({ handler: { pull } }) => !!pull)
-                .map(({ handler: { key, pull }, config }) => {
-                    logger.silly(`pulling from ${chalk.yellow(key)} provider`);
-
-                    return pull!(argv, config);
-                })
-        );
-
-        if (promises.length > 0)
-            logger.info('environment variables pulled successfully');
-        else logger.warn('no providers for pull variables');
-    }
-};

package/src/commands/push.command.ts

@@ -1,48 +0,0 @@
-import chalk from 'chalk';
-import { CommandModule } from 'yargs';
-import { CommandArguments } from '../arguments';
-import { logger } from '../utils';
-
-export interface PushCommandArguments extends CommandArguments {
-    // forces to push in case of conflict
-    force: boolean;
-}
-
-/**
- * Pushes environment variables to providers store.
- *
- * @example [>_]: env push -e dev
- */
-export const pushCommand: CommandModule<any, PushCommandArguments> = {
-    command: 'push [options..]',
-    describe: 'Pushes environment variables to providers store',
-    builder: (builder) => {
-        builder
-            .options({
-                force: {
-                    alias: 'f',
-                    type: 'boolean',
-                    default: false,
-                    describe: 'Force push for secrets'
-                }
-            })
-            .example('env push -e dev', 'Download "dev" environment secrets');
-
-        return builder;
-    },
-    handler: async ({ providers, ...argv }) => {
-        const promises = await Promise.all(
-            providers
-                .filter(({ handler: { push } }) => !!push)
-                .map(({ handler: { key, push }, config }) => {
-                    logger.debug(`pushing to ${chalk.yellow(key)} provider`);
-
-                    return push!(argv, config);
-                })
-        );
-
-        if (promises.length > 0)
-            logger.info('environment variables pushed successfully');
-        else logger.warn('no providers for push variables');
-    }
-};

package/src/commands/schema.command.ts

@@ -1,31 +0,0 @@
-import { CommandModule } from 'yargs';
-import { CommandArguments } from '../arguments';
-import {
-    generateSchemaFrom,
-    loadVariablesFromProviders,
-    logger
-} from '../utils';
-
-/**
- * Generates validation schema from providers environment variables.
- *
- * @example [>_]: env schema -e dev -m build
- */
-export const schemaCommand: CommandModule<any, CommandArguments> = {
-    command: 'schema [options..]',
-    describe: 'Generates validation schema from providers',
-    builder: (builder) => {
-        return builder.example(
-            'env schema --generate -e dev -m debug unit',
-            'Updates JSON schema'
-        );
-    },
-    handler: async (argv) => {
-        const results = await loadVariablesFromProviders(argv.providers, argv);
-
-        const schema = await generateSchemaFrom(results, argv);
-
-        logger.silly('schema:', schema);
-        logger.info('schema updated successfully');
-    }
-};

package/src/exec.ts

@@ -1,221 +0,0 @@
-#!/usr/bin/env node
-
-import chalk from 'chalk';
-import yargsParser from 'yargs-parser';
-import yargs, { Arguments } from 'yargs';
-import { IntegratedProviders } from './providers';
-import { args, CommandArguments } from './arguments';
-import {
-    envCommand,
-    exportCommand,
-    pullCommand,
-    pushCommand,
-    schemaCommand
-} from './commands';
-import {
-    getSubcommand,
-    interpolateJson,
-    loadConfigFile,
-    loadProjectInfo,
-    loadSchemaFile,
-    logger,
-    resolvePath
-} from './utils';
-
-type Alias = string | string[];
-
-/**
- * Preload basic config from command line and config file.
- *
- * @param {string[]} rawArgv process.argv
- * @param {Partial<yargsParser.Configuration>} parser yargs parser config
- * @param {[string, string]} delimiters
- *
- * @returns {Promise<Partial<CommandArguments>>} preloaded config
- */
-async function preloadConfig(
-    rawArgv: string[],
-    parser: Partial<yargsParser.Configuration>,
-    delimiters: [string, string]
-): Promise<Partial<CommandArguments>> {
-    // preload base config
-    const preloadedArgv = yargsParser(rawArgv, {
-        configuration: parser,
-        boolean: ['help'],
-        string: ['root', 'env', 'configFile', 'schemaFile', 'logLevel'],
-        array: ['modes', 'logMaskAnyRegEx', 'logMaskValuesOfKeys'],
-        alias: {
-            env: args.env.alias as Alias,
-            modes: args.modes.alias as Alias,
-            configFile: args.configFile.alias as Alias,
-            logLevel: args.logLevel.alias as Alias,
-            logMaskAnyRegEx: args.logMaskAnyRegEx.alias as Alias,
-            logMaskValuesOfKeys: args.logMaskValuesOfKeys.alias as Alias
-        },
-        default: {
-            root: args.root.default,
-            configFile: args.configFile.default
-        }
-    });
-
-    // loads configuration file
-    await loadConfigFile(preloadedArgv, delimiters);
-
-    preloadedArgv.logLevel ??= args.logLevel.default;
-    preloadedArgv.logMaskAnyRegEx ??= args.logMaskAnyRegEx.default;
-    preloadedArgv.logMaskValuesOfKeys ??= args.logMaskValuesOfKeys.default;
-    preloadedArgv.providers ??= args.providers.default;
-
-    const { logLevel, logMaskAnyRegEx, logMaskValuesOfKeys } = preloadedArgv;
-
-    // logging level
-    logger.setSettings({
-        minLevel: logLevel,
-        maskAnyRegEx: logMaskAnyRegEx,
-        maskValuesOfKeys: logMaskValuesOfKeys
-    });
-
-    return preloadedArgv;
-}
-
-/**
- * Command preprocessing and lib info
- * reading from package.json.
- * Preloads config file and setup basic config.
- *
- * @param {string[]} rawArgv process.argv
- */
-export async function exec(rawArgv: string[]) {
-    // reads some lib base config from package.json
-    const { config, version } = await import(`${__dirname}/package.json`);
-
-    // execs yargs
-    const subcommand = getSubcommand(rawArgv, config.delimiters.subcommand);
-
-    const preloadedArgv = await preloadConfig(
-        rawArgv,
-        config.parser,
-        config.delimiters.template
-    );
-
-    const { env, modes, providers, help } = preloadedArgv;
-
-    if (help) build(rawArgv, preloadedArgv, subcommand, config, version);
-
-    if (!Array.isArray(providers) || providers.length === 0) {
-        logger.error('no providers found');
-
-        process.exit(1);
-    }
-
-    logger.info(
-        `loading ${chalk.bold.underline.green(env)} environment` +
-            (modes ? ` in ${chalk.bold.magenta(modes.join('+'))} mode` : '')
-    );
-
-    // read loaders from config
-    for (const provider of providers!) {
-        try {
-            logger.debug(`using ${chalk.yellow(provider.path)} provider`);
-
-            if (!provider.type || provider.type === 'integrated') {
-                provider.handler = IntegratedProviders[provider.path];
-            } else {
-                const { default: module } = await import(
-                    provider.type === 'module'
-                        ? provider.path
-                        : resolvePath(provider.path)
-                );
-
-                provider.handler = module;
-            }
-        } catch {
-            logger.error(
-                `${chalk.yellow(
-                    provider.path
-                )} provider not found or not compatible`
-            );
-
-            process.exit(1);
-        }
-    }
-
-    build(rawArgv, preloadedArgv, subcommand, config, version);
-}
-
-/**
- * Builds commands and execs Yargs.
- *
- * @param {string[]} rawArgv process.argv.slice(2)
- * @param {Partial<Arguments<CommandArguments>>} preloadedArgv
- * @param {string[]} subcommand subcommand for wrap if exists
- * @param {Record<string, any>} config lib config from package.json
- * @param {string} version lib version from package.json
- */
-function build(
-    rawArgv: string[],
-    preloadedArgv: Partial<Arguments<CommandArguments>>,
-    subcommand: string[],
-    config: Record<string, any>,
-    version = 'unknown'
-): void {
-    const builder = yargs(rawArgv)
-        .strict()
-        .scriptName('env')
-        .version(version)
-        .detectLocale(false)
-        .showHelpOnFail(false)
-        .parserConfiguration(config.parser)
-        .usage('Usage: $0 [command] [options..] [: subcmd [:]] [options..]')
-        .options(args)
-        .middleware(async (argv): Promise<void> => {
-            // in case of subcommand argument for main
-            if (subcommand?.length > 0) argv.subcmd = subcommand;
-
-            // merges preloaded args
-            Object.assign(argv, preloadedArgv);
-
-            logger.silly(
-                'interpolating arguments surrounded by',
-                chalk.bold.yellow(
-                    config.delimiters.template[0],
-                    config.delimiters.template[1]
-                )
-            );
-
-            // applies string templating with current vars
-            interpolateJson(argv, argv, config.delimiters.template);
-
-            logger.silly('config loaded:', argv);
-
-            // loads environment JSON schema if exists
-            // and current project info from package.json
-            [argv.app, argv.schema] = await Promise.all([
-                loadProjectInfo(),
-                loadSchemaFile(argv, config.delimiters.template)
-            ]);
-
-            if (argv.schemaValidate) {
-                argv.schemaValidate = !!argv.schema;
-
-                if (argv.schemaValidate)
-                    logger.silly('schema loaded:', argv.schema);
-            }
-        });
-
-    // integrated commands builder
-    builder.command(envCommand);
-    builder.command(exportCommand);
-    builder.command(pullCommand);
-    builder.command(pushCommand);
-    builder.command(schemaCommand);
-
-    const { providers } = preloadedArgv;
-
-    // extends command from plugins
-    for (const { handler } of providers!)
-        handler?.builder && handler.builder(builder);
-
-    // executes command processing
-    builder.parse();
-}

package/src/interfaces/loader.interface.ts

@@ -1,66 +0,0 @@
-import { Arguments, Argv } from 'yargs';
-
-/**
- * Result of provider environment load.
- *
- * @export
- * @type EnvResult
- */
-export type EnvResult =
-    | Record<string, unknown>
-    | Record<string, unknown>[]
-    | Promise<Record<string, unknown>>
-    | Promise<Record<string, unknown>[]>;
-
-/**
- * Wrapped provider result for inject to env.
- *
- * @export
- * @interface EnvProviderResult
- */
-export interface EnvProviderResult {
-    key: string;
-    config?: Record<string, unknown>;
-    value: Record<string, any> | Record<string, any>[];
-}
-
-/**
- * Provider handler.
- *
- * @export
- * @interface EnvProvider
- * @template A define arguments used by provider
- * @template C define config used by provider
- */
-export interface EnvProvider<
-    A,
-    C extends Record<string, any> | undefined = undefined
-> {
-    // unique key
-    key: string;
-
-    // modifies command building (adds or modifies commands, options .etc)
-    builder?: (builder: Argv<unknown>) => void;
-
-    // loads environment variables.
-    load: (argv: Arguments<A>, config?: C) => EnvResult | never;
-
-    // pulls vars
-    pull?: (argv: Arguments<A>, config?: C) => void;
-
-    // push vars
-    push?: (argv: Arguments<A>, config?: C) => void;
-}
-
-/**
- * Provider definition for config file.
- *
- * @export
- * @interface EnvProviderConfig
- */
-export interface EnvProviderConfig {
-    path: string;
-    type: 'integrated' | 'module' | 'script';
-    handler: EnvProvider<any, any>;
-    config?: Record<string, unknown>;
-}

package/src/main.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-
-import { exec } from './exec';
-
-// runs the program
-exec(process.argv.slice(2));