@quonfig/cli 0.0.1

package/dist/commands/generate.js

@@ -0,0 +1,220 @@
+import { Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { z } from 'zod';
+import { NodeTypeScriptGenerator } from '../codegen/code-generators/node-typescript-generator.js';
+import { ReactTypeScriptGenerator } from '../codegen/code-generators/react-typescript-generator.js';
+import { ConfigDownloader } from '../codegen/config-downloader.js';
+import { SupportedLanguage } from '../codegen/types.js';
+import { APICommand } from '../index.js';
+import { createFileManager } from '../util/file-manager.js';
+// base types
+const nodeOrReactLanguageSpecificSchema = z.object({
+    clientFileName: z.string().optional(),
+    declarationFileName: z.string().optional(),
+    outputDirectory: z.string().optional(),
+});
+/**
+ * Types for parsed config schema
+ *
+ * {
+ *   <react|node>: {
+ *     clientFileName: string;
+ *     declarationFileName: string;
+ *     outputDirectory: string;
+ *   },
+ * }
+ */
+const requiredNodeOrReactLanguageSpecificSchema = nodeOrReactLanguageSpecificSchema.required();
+const allLanguageEntries = {
+    [SupportedLanguage.Node]: requiredNodeOrReactLanguageSpecificSchema,
+    [SupportedLanguage.React]: requiredNodeOrReactLanguageSpecificSchema,
+};
+const parsedConfigSchema = z.object(allLanguageEntries);
+/**
+ * Types for input config schema
+ *
+ * {
+ *   outputDiretory?: string;
+ *   targets?: {
+ *     <supported language>?: {
+ *       outputDirectory: string;
+ *       outputFileName: string;
+ *     },
+ *   },
+ * }
+ */
+const allTargetsSchema = z.object({
+    [SupportedLanguage.Node]: nodeOrReactLanguageSpecificSchema.optional(),
+    [SupportedLanguage.React]: nodeOrReactLanguageSpecificSchema.optional(),
+});
+const inputConfigSchema = z.object({
+    outputDirectory: z.string().optional(),
+    targets: allTargetsSchema.optional(),
+});
+const CONFIG_NAME = 'quonfig.config.json';
+const DEFAULT_CONFIG = {
+    outputDirectory: 'generated',
+    targets: {
+        'node-ts': {
+            clientFileName: 'quonfig-server.ts',
+            declarationFileName: 'quonfig-server-types.d.ts',
+        },
+        'react-ts': {
+            clientFileName: 'quonfig-client.ts',
+            declarationFileName: 'quonfig-client-types.d.ts',
+        },
+    },
+};
+export default class Generate extends APICommand {
+    /* eslint-disable no-irregular-whitespace */
+    static description = `You can use the default type-generation configuration, or by provide your own via a quonfig.config.json file:
+
+Format:
+{
+​  outputDirectory?: string;
+​  targets?: {
+​    <language key>?: {
+​      outputDirectory?: string;
+​      outputFileName?: string;
+​    }
+​  }
+};
+
+Example quonfig.config.json:
+\`\`\`json
+{
+​  "outputDirectory": "path/to/your/directory",
+​  "targets": {
+​    "react-ts": {
+​      "outputDirectory": "diff/path/to/your/directory",
+​      "declarationFileName": "quonfig-client-types.d.ts",
+​      "clientFileName": "quonfig-client.ts",
+​    },
+​    "node-ts": {
+​      "declarationFileName": "quonfig-server-types.d.ts",
+​      "clientFileName": "quonfig-server.ts",
+​    }
+​  }
+}
+\`\`\`
+  `;
+    /* eslint-enable no-irregular-whitespace */
+    static examples = [
+        '<%= config.bin %> <%= command.id %> # react-ts only by default',
+        '<%= config.bin %> <%= command.id %> --targets node-ts # node-ts only',
+        '<%= config.bin %> <%= command.id %> --targets react-ts,node-ts # both node + react-ts',
+        '<%= config.bin %> <%= command.id %> -o ./src/generated # specify output directory',
+        '<%= config.bin %> <%= command.id %> --targets node-ts -o ./dist # combine with targets',
+    ];
+    static flags = {
+        'output-directory': Flags.string({
+            char: 'o',
+            description: 'Override the output directory for generated files',
+        }),
+        targets: Flags.string({
+            default: SupportedLanguage.React,
+            description: `Determines for language/framework to generate code for (${Object.values(SupportedLanguage).join(', ')})`,
+        }),
+    };
+    static summary = 'Generate type definitions for your Quonfig configuration';
+    async run() {
+        const { flags } = await this.parse(Generate);
+        this.verboseLog('=== GENERATE COMMAND START ===');
+        this.verboseLog(`Base API URL: ${process.env.QUONFIG_API_URL || 'Default'}`);
+        try {
+            // Look for and read local quonfig.config.json file
+            const localConfig = await this.readLocalConfig(flags['output-directory']);
+            // Use tarets flag override, otherwise fall back to local config
+            const targets = flags.targets.split(',') || Object.keys(localConfig);
+            this.verboseLog(`Language(s): ${targets.join(', ')}`);
+            // Download the configuration using the APICommand's client
+            const downloader = new ConfigDownloader(this);
+            this.verboseLog('Downloading config...');
+            const configFile = await downloader.downloadConfig();
+            this.verboseLog('Config download complete.');
+            const fileCreationPromises = [];
+            for (const target of targets) {
+                // Resolve the language input
+                const language = this.resolveLanguage(target);
+                // Get language-specific config or fall back to global config
+                const targetConfig = localConfig[language];
+                const outputDir = targetConfig.outputDirectory;
+                this.verboseLog(`Output directory for ${target}: ${outputDir}`);
+                this.verboseLog('Resolving generator...');
+                const generator = this.resolveGenerator(language, configFile);
+                console.log(`Generating ${language} code for configs...`);
+                const generatedCode = generator.generate();
+                this.verboseLog(`Code generation complete. Size: ${generatedCode.length}`);
+                const fileManager = createFileManager({ outputDirectory: outputDir, verboseLog: this.verboseLog.bind(this) });
+                fileCreationPromises.push(fileManager.writeFile({ data: generatedCode, filename: targetConfig.clientFileName }));
+                if ([SupportedLanguage.Node, SupportedLanguage.React].includes(language)) {
+                    const declarationGeneratedCode = generator.declarationGenerate();
+                    this.verboseLog(`Code generation complete. Size: ${declarationGeneratedCode.length}`);
+                    fileCreationPromises.push(fileManager.writeFile({ data: declarationGeneratedCode, filename: targetConfig.declarationFileName }));
+                }
+            }
+            await Promise.all(fileCreationPromises);
+        }
+        catch (error) {
+            console.error('ERROR:', error);
+            this.error(error);
+        }
+        this.verboseLog('=== GENERATE COMMAND END ===');
+        return { success: true };
+    }
+    generateParsedConfig(jsonConfig = {}, outputDirectoryOverride) {
+        const parsedConfig = inputConfigSchema.parse(jsonConfig);
+        return Object.values(SupportedLanguage).reduce((agg, language) => {
+            const parsedLanguageConfig = parsedConfig.targets?.[language] || {};
+            const languageConfig = {
+                clientFileName: parsedLanguageConfig.clientFileName || DEFAULT_CONFIG.targets[language].clientFileName,
+                declarationFileName: parsedLanguageConfig.declarationFileName || DEFAULT_CONFIG.targets[language].declarationFileName,
+                outputDirectory: outputDirectoryOverride ||
+                    parsedLanguageConfig.outputDirectory ||
+                    parsedConfig.outputDirectory ||
+                    DEFAULT_CONFIG.outputDirectory,
+            };
+            agg[language] = languageConfig;
+            return agg;
+        }, {});
+    }
+    async readLocalConfig(outputDirectoryOverride) {
+        const configPath = path.join(process.cwd(), CONFIG_NAME);
+        try {
+            // Check if file exists
+            await fs.promises.access(configPath, fs.constants.F_OK);
+            this.verboseLog(`Found local ${CONFIG_NAME}`);
+            // Read and parse the file
+            const configContent = await fs.promises.readFile(configPath, 'utf8');
+            const parsedConfig = JSON.parse(configContent);
+            this.verboseLog(`Local config loaded from ${CONFIG_NAME}: ${JSON.stringify(parsedConfig, null, 2)}`);
+            return this.generateParsedConfig(parsedConfig, outputDirectoryOverride);
+        }
+        catch (error) {
+            // File doesn't exist or can't be read/parsed
+            if (error.code === 'ENOENT') {
+                this.verboseLog(`No ${CONFIG_NAME} file found in current directory.`);
+            }
+            else {
+                this.error(`Error reading ${CONFIG_NAME}: ${error}`);
+            }
+            return this.generateParsedConfig({}, outputDirectoryOverride);
+        }
+    }
+    resolveGenerator(language, configFile) {
+        switch (language) {
+            case SupportedLanguage.Node:
+                return new NodeTypeScriptGenerator({ configFile, log: this.verboseLog });
+            case SupportedLanguage.React:
+                return new ReactTypeScriptGenerator({ configFile, log: this.verboseLog });
+        }
+    }
+    resolveLanguage(languageTarget) {
+        const target = languageTarget?.toLowerCase();
+        if (!target || !Object.values(SupportedLanguage).includes(target)) {
+            throw new Error(`Unsupported target: ${languageTarget}`);
+        }
+        return target;
+    }
+}

package/dist/commands/get.d.ts

@@ -0,0 +1,13 @@
+import { APICommand } from '../index.js';
+import { JsonObj } from '../result.js';
+export default class Get extends APICommand {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        environment: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<JsonObj | void>;
+}

package/dist/commands/get.js

@@ -0,0 +1,141 @@
+import { Flags } from '@oclif/core';
+import { APICommand } from '../index.js';
+import autocomplete from '../util/autocomplete.js';
+import getEnvironment from '../ui/get-environment.js';
+import isInteractive from '../util/is-interactive.js';
+import nameArg from '../util/name-arg.js';
+import { decrypt } from '../util/encryption.js';
+export default class Get extends APICommand {
+    static args = { ...nameArg };
+    static description = 'Get the value of a config/feature-flag/etc.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my.config.name',
+        '<%= config.bin %> <%= command.id %> my.config.name --environment=production',
+    ];
+    static flags = {
+        environment: Flags.string({ description: 'environment to evaluate in' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Get);
+        // Fetch metadata first for validation and autocomplete
+        const metadataRequest = await this.apiClient.post('/api/v1/metadata/list', { workspaceId: this.workspaceId });
+        if (!metadataRequest.ok) {
+            const errorMsg = metadataRequest.error?.error || `Failed to fetch configs: ${metadataRequest.status}`;
+            return this.err(errorMsg, { serverError: metadataRequest.error });
+        }
+        const metadataResponse = metadataRequest.json;
+        const configKeys = metadataResponse.configs.map((c) => c.key);
+        // Get the key with autocomplete
+        let key = args.name;
+        if (!key && isInteractive(flags)) {
+            const selectedKey = await autocomplete({
+                message: 'Config key',
+                source: configKeys,
+            });
+            if (selectedKey) {
+                key = selectedKey;
+            }
+        }
+        if (!key) {
+            return this.err('Key is required');
+        }
+        // Validate key exists
+        const configExists = metadataResponse.configs.some((config) => config.key === key);
+        if (!configExists) {
+            return this.err(`${key} does not exist`);
+        }
+        // Get the environment
+        const environment = await getEnvironment({
+            command: this,
+            flags,
+            message: 'Which environment would you like to evaluate in?',
+            providedEnvironment: flags.environment,
+        });
+        if (!environment) {
+            return;
+        }
+        const request = await this.apiClient.post('/api/v1/evaluations/evaluate', {
+            workspaceId: this.workspaceId,
+            environmentId: environment.id,
+            context: {},
+        });
+        if (!request.ok) {
+            const errorMsg = request.error?.error || `Failed to get config: ${request.status}`;
+            return this.err(errorMsg, { serverError: request.error });
+        }
+        // oRPC returns EvaluationResult[] — find the matching key
+        const results = (Array.isArray(request.json) ? request.json : []);
+        const result = results.find((r) => r.key === key);
+        if (!result) {
+            return this.err(`${key} could not be evaluated in this environment`);
+        }
+        // Adapt to the legacy response shape for downstream compatibility
+        const config = {
+            key: result.key,
+            type: result.configType,
+            value: result.displayValue,
+            metadata: {
+                conditionalValueIndex: 0,
+                configRowIndex: 0,
+                id: 0,
+                type: result.configType,
+                valueType: result.valueType,
+            },
+        };
+        let value = config.value;
+        // Check if this config has dependencies
+        if (config.dependencies && config.dependencies.length > 0) {
+            // Check for providedBy dependency (config value from env var)
+            const providedByDep = config.dependencies.find((dep) => dep.dependencyType === 'providedBy');
+            if (providedByDep) {
+                const envVarName = providedByDep.source;
+                this.log(`This config is provided by env var '${envVarName}'`);
+                // Check if the env var is present
+                const envValue = process.env[envVarName];
+                if (!envValue) {
+                    return this.err(`Environment variable '${envVarName}' is not set. Cannot resolve config '${key}'.`, {
+                        [key]: value,
+                        provided: true,
+                        missingEnvVar: envVarName,
+                    });
+                }
+                value = envValue;
+                this.log(`Successfully resolved config '${key}' from env var`);
+            }
+            // Check for decryptWith dependency (encrypted config)
+            const decryptWithDep = config.dependencies.find((dep) => dep.dependencyType === 'decryptWith');
+            if (decryptWithDep && decryptWithDep.config) {
+                const encryptionKeyConfig = decryptWithDep.config;
+                // Find the providedBy dependency to get the env var name for the encryption key
+                const keyProvidedByDep = encryptionKeyConfig.dependencies?.find((dep) => dep.dependencyType === 'providedBy');
+                if (keyProvidedByDep) {
+                    const envVarName = keyProvidedByDep.source;
+                    this.log(`This config is encrypted by key '${encryptionKeyConfig.key}' that should be found in env var '${envVarName}'`);
+                    // Check if the env var is present
+                    const encryptionKey = process.env[envVarName];
+                    if (!encryptionKey) {
+                        return this.err(`Environment variable '${envVarName}' is not set. Cannot decrypt config '${key}'.`, {
+                            [key]: value,
+                            encrypted: true,
+                            missingEnvVar: envVarName,
+                        });
+                    }
+                    // Attempt decryption
+                    try {
+                        value = decrypt(value, encryptionKey);
+                        this.log(`Successfully decrypted config '${key}'`);
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        return this.err(`Failed to decrypt config '${key}': ${errorMessage}`, {
+                            [key]: value,
+                            encrypted: true,
+                            error: errorMessage,
+                        });
+                    }
+                }
+            }
+        }
+        return this.ok(this.toSuccessJson(value), { [key]: value });
+    }
+}

package/dist/commands/info.d.ts

@@ -0,0 +1,21 @@
+import { APICommand } from '../index.js';
+import { JsonObj } from '../result.js';
+export default class Info extends APICommand {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'exclude-evaluations': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<JsonObj | void>;
+    private displayEvaluationStats;
+    private extractSimpleValue;
+    private fetchEvaluationStats;
+    private formatValue;
+    private hasNonTrivialCriteria;
+    private parseConfig;
+    private transformEvaluationStatsForJson;
+    private transformValueForJson;
+}