@achs/env 2.0.0 → 3.1.0

package/src/interfaces/loader.interface.ts

@@ -0,0 +1,66 @@
+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

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

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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,277 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,39 @@
+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
+        };
+    }
+};