@quonfig/cli 0.0.1

package/dist/codegen/zod-introspection.d.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { $ZodFunctionArgs, $ZodFunctionOut, $ZodType, util, $ZodRecordKey } from 'zod/v4/core';
+export declare function isString(schema: $ZodType): schema is z.ZodString;
+export declare function isNumber(schema: $ZodType): schema is z.ZodNumber;
+export declare function isBoolean(schema: $ZodType): schema is z.ZodBoolean;
+export declare function isNull(schema: $ZodType): schema is z.ZodNull;
+export declare function isLiteral(schema: $ZodType): schema is z.ZodLiteral<string | number | boolean | null>;
+export declare function isUndefined(schema: $ZodType): schema is z.ZodUndefined;
+export declare function isUnknown(schema: $ZodType): schema is z.ZodUnknown;
+export declare function isNever(schema: $ZodType): schema is z.ZodNever;
+export declare function isAny(schema: $ZodType): schema is z.ZodAny;
+export declare function isArray(schema: $ZodType): schema is z.ZodArray<z.ZodTypeAny>;
+export declare function isObject(schema: $ZodType): schema is z.ZodObject<z.ZodRawShape>;
+export declare function isTuple(schema: $ZodType): schema is z.ZodTuple;
+export declare function isRecord(schema: $ZodType): schema is z.ZodRecord;
+export declare function isEnum(schema: $ZodType): schema is z.ZodEnum<util.EnumLike>;
+export declare function isUnion(schema: $ZodType): schema is z.ZodUnion<[z.ZodTypeAny, ...z.ZodTypeAny[]]>;
+export declare function isOptional(schema: $ZodType): schema is z.ZodOptional<z.ZodTypeAny>;
+export declare function isNullable(schema: $ZodType): schema is z.ZodNullable<z.ZodTypeAny>;
+export declare function isDefault(schema: $ZodType): schema is z.ZodDefault<z.ZodTypeAny>;
+export declare function isFunction(schema: $ZodType): schema is z.ZodFunction<$ZodFunctionArgs, $ZodFunctionOut>;
+/**
+ * Gets the element type from an array schema
+ */
+export declare function getArrayElement(schema: z.ZodArray<z.ZodTypeAny>): z.ZodTypeAny;
+/**
+ * Gets the shape from an object schema
+ */
+export declare function getObjectShape(schema: z.ZodObject<z.ZodRawShape>): z.ZodRawShape;
+/**
+ * Gets the items from a tuple schema
+ */
+export declare function getTupleItems(schema: z.ZodTuple): readonly $ZodType[];
+/**
+ * Gets the key and value types from a record schema
+ */
+export declare function getRecordTypes(schema: z.ZodRecord): {
+    keyType: $ZodRecordKey;
+    valueType: $ZodType;
+};
+/**
+ * Gets the enum values from an enum schema
+ */
+export declare function getEnumValues(schema: z.ZodEnum<util.EnumLike>): util.EnumValue[];
+export declare function getLiteralValue(schema: z.ZodLiteral<string | number | boolean | null>): string | number | boolean | null;
+/**
+ * Gets the options from a union schema
+ */
+export declare function getUnionOptions(schema: z.ZodUnion<[z.ZodTypeAny, ...z.ZodTypeAny[]]>): z.ZodTypeAny[];
+/**
+ * Unwraps an optional schema to get its inner type
+ */
+export declare function unwrapOptional(schema: z.ZodOptional<z.ZodTypeAny>): z.ZodTypeAny;
+/**
+ * Unwraps a nullable schema to get its inner type
+ */
+export declare function unwrapNullable(schema: z.ZodNullable<z.ZodTypeAny>): z.ZodTypeAny;
+/**
+ * Unwraps a default schema to get its inner type and default value
+ */
+export declare function unwrapDefault(schema: z.ZodDefault<z.ZodTypeAny>): {
+    defaultValue: unknown;
+    innerType: z.ZodTypeAny;
+};
+/**
+ * Gets function arguments and return type from a function schema
+ */
+export declare function getFunctionSignature(schema: z.ZodFunction<$ZodFunctionArgs, $ZodFunctionOut>): {
+    args: $ZodFunctionArgs;
+    returns: $ZodFunctionOut;
+};
+/**
+ * Checks if a number schema has integer constraint
+ */
+export declare function isNumberInteger(schema: z.ZodNumber): boolean;
+/**
+ * Gets metadata from a schema if it has been set with .meta()
+ */
+export declare function getMeta(schema: $ZodType): Record<string, unknown> | undefined;
+/**
+ * Gets a comment string from metadata.
+ * If meta only contains a description key, returns the description string.
+ * Otherwise, returns a JSON representation of the entire meta object.
+ */
+export declare function getMetaDescription(schema: $ZodType): string | undefined;

package/dist/codegen/zod-introspection.js

@@ -0,0 +1,205 @@
+import { z } from 'zod';
+// ============================================================================
+// Type Guards
+// ============================================================================
+export function isString(schema) {
+    return schema instanceof z.ZodString;
+}
+export function isNumber(schema) {
+    return schema instanceof z.ZodNumber;
+}
+export function isBoolean(schema) {
+    return schema instanceof z.ZodBoolean;
+}
+export function isNull(schema) {
+    return schema instanceof z.ZodNull;
+}
+export function isLiteral(schema) {
+    return schema instanceof z.ZodLiteral;
+}
+export function isUndefined(schema) {
+    return schema instanceof z.ZodUndefined;
+}
+export function isUnknown(schema) {
+    return schema instanceof z.ZodUnknown;
+}
+export function isNever(schema) {
+    return schema instanceof z.ZodNever;
+}
+export function isAny(schema) {
+    return schema instanceof z.ZodAny;
+}
+export function isArray(schema) {
+    return schema instanceof z.ZodArray;
+}
+export function isObject(schema) {
+    return schema instanceof z.ZodObject;
+}
+export function isTuple(schema) {
+    return schema instanceof z.ZodTuple;
+}
+export function isRecord(schema) {
+    return schema instanceof z.ZodRecord;
+}
+export function isEnum(schema) {
+    return schema instanceof z.ZodEnum;
+}
+export function isUnion(schema) {
+    return schema instanceof z.ZodUnion;
+}
+export function isOptional(schema) {
+    return schema instanceof z.ZodOptional;
+}
+export function isNullable(schema) {
+    return schema instanceof z.ZodNullable;
+}
+export function isDefault(schema) {
+    return schema instanceof z.ZodDefault;
+}
+export function isFunction(schema) {
+    return schema instanceof z.ZodFunction;
+}
+function isCheckNumberFormat(checkDef) {
+    return checkDef?.check === 'number_format';
+}
+// ============================================================================
+// Property Extractors
+// ============================================================================
+/**
+ * Gets the element type from an array schema
+ */
+export function getArrayElement(schema) {
+    return schema.def.element;
+}
+/**
+ * Gets the shape from an object schema
+ */
+export function getObjectShape(schema) {
+    return schema.def.shape;
+}
+/**
+ * Gets the items from a tuple schema
+ */
+export function getTupleItems(schema) {
+    return schema.def.items;
+}
+/**
+ * Gets the key and value types from a record schema
+ */
+export function getRecordTypes(schema) {
+    return {
+        keyType: schema.def.keyType,
+        valueType: schema.def.valueType,
+    };
+}
+/**
+ * Gets the enum values from an enum schema
+ */
+export function getEnumValues(schema) {
+    // In v4, enum entries is an object like { "a": "a", "b": "b", "c": "c" }
+    const entries = schema.def.entries;
+    if (entries && typeof entries === 'object') {
+        return Object.values(entries);
+    }
+    return [];
+}
+export function getLiteralValue(schema) {
+    return schema.def.values[0];
+}
+/**
+ * Gets the options from a union schema
+ */
+export function getUnionOptions(schema) {
+    return schema.def.options || [];
+}
+/**
+ * Unwraps an optional schema to get its inner type
+ */
+export function unwrapOptional(schema) {
+    return schema.def.innerType;
+}
+/**
+ * Unwraps a nullable schema to get its inner type
+ */
+export function unwrapNullable(schema) {
+    return schema.def.innerType;
+}
+/**
+ * Unwraps a default schema to get its inner type and default value
+ */
+export function unwrapDefault(schema) {
+    return {
+        defaultValue: schema.def.defaultValue,
+        innerType: schema.def.innerType,
+    };
+}
+/**
+ * Gets function arguments and return type from a function schema
+ */
+export function getFunctionSignature(schema) {
+    // In v4, function uses input/output properties
+    return {
+        args: schema.def.input,
+        returns: schema.def.output,
+    };
+}
+/**
+ * Checks if a number schema has integer constraint
+ */
+export function isNumberInteger(schema) {
+    const checks = schema.def.checks || [];
+    // Look for number_format check with integer formats
+    return checks.some((check) => {
+        const checkDef = check._zod?.def;
+        if (isCheckNumberFormat(checkDef)) {
+            const format = checkDef.format;
+            return format === 'int32' || format === 'uint32' || format === 'safeint';
+        }
+        return false;
+    });
+}
+/**
+ * Gets metadata from a schema if it has been set with .meta()
+ */
+export function getMeta(schema) {
+    if (!schema) {
+        return undefined;
+    }
+    // Call .meta() without arguments to retrieve metadata
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (typeof schema.meta === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return schema.meta();
+    }
+    return undefined;
+}
+/**
+ * Gets a comment string from metadata.
+ * If meta only contains a description key, returns the description string.
+ * Otherwise, returns a JSON representation of the entire meta object.
+ */
+export function getMetaDescription(schema) {
+    const meta = getMeta(schema);
+    if (!meta || Object.keys(meta).length === 0) {
+        return undefined;
+    }
+    // If meta only has a description key, return just the description
+    const keys = Object.keys(meta);
+    if (keys.length === 1 && keys[0] === 'description' && typeof meta.description === 'string') {
+        return meta.description;
+    }
+    if (typeof meta.description === 'string') {
+        return meta.description;
+    }
+    if (typeof meta.title === 'string') {
+        return meta.title;
+    }
+    // Otherwise, return JSON representation of the entire meta object
+    try {
+        return JSON.stringify(meta, null, 2);
+    }
+    catch {
+        // If JSON serialization fails, return undefined
+        return undefined;
+    }
+}

package/dist/commands/create.d.ts

@@ -0,0 +1,19 @@
+import { APICommand } from '../index.js';
+import { JsonObj } from '../result.js';
+export default class Create extends APICommand {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        secret: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'secret-key-name': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        confidential: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'env-var': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        value: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<JsonObj | void>;
+    private createBooleanFlag;
+}

package/dist/commands/create.js

@@ -0,0 +1,175 @@
+import { Args, Flags } from '@oclif/core';
+import { ProvidedSource } from '@quonfig/node';
+import { APICommand } from '../index.js';
+import getValue from '../ui/get-value.js';
+import { TYPE_MAPPING, coerceBool, coerceIntoType } from '../util/coerce.js';
+import { checkmark } from '../util/color.js';
+import { mapConfigValueToDto, mapValueTypeToString } from '../util/config-value-dto.js';
+import { makeConfidentialValue } from '../util/encryption.js';
+import secretFlags, { parsedSecretFlags } from '../util/secret-flags.js';
+export default class Create extends APICommand {
+    static args = {
+        name: Args.string({ description: 'name for your new item (e.g. my.new.flag)', required: true }),
+    };
+    static description = 'Create a new item in Quonfig';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my.new.flag --type boolean-flag',
+        '<%= config.bin %> <%= command.id %> my.new.flag --type boolean-flag --value=true',
+        '<%= config.bin %> <%= command.id %> my.new.string --type string --value="hello world"',
+        '<%= config.bin %> <%= command.id %> my.new.string --type string --value="hello world" --secret',
+        '<%= config.bin %> <%= command.id %> my.new.string --type string --env-var=MY_ENV_VAR_NAME',
+        '<%= config.bin %> <%= command.id %> my.new.string --type json --value="{\\"key\\": \\"value\\"}"',
+    ];
+    static flags = {
+        confidential: Flags.boolean({ default: false, description: 'mark the value as confidential' }),
+        'env-var': Flags.string({ description: 'environment variable to get value from' }),
+        type: Flags.string({
+            options: ['boolean-flag', 'boolean', 'string', 'double', 'int', 'string-list', 'json'],
+            required: true,
+        }),
+        value: Flags.string({ description: 'default value for your new item', required: false }),
+        ...secretFlags('encrypt the value of this item'),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Create);
+        if (flags.type === 'boolean-flag') {
+            return this.createBooleanFlag(args, flags.value);
+        }
+        const key = args.name;
+        const secret = parsedSecretFlags(flags);
+        if (flags['env-var'] && flags.value) {
+            return this.err('cannot specify both --env-var and --value');
+        }
+        if (flags['env-var'] && secret.selected) {
+            return this.err('cannot specify both --env-var and --secret');
+        }
+        if (flags.confidential && secret.selected) {
+            console.warn("Note: --confidential is implied when using --secret, so you don't need to specify both.");
+        }
+        if (secret.selected && flags.type !== 'string') {
+            return this.err('--secret flag only works with string type');
+        }
+        let configValue = {};
+        let valueType = TYPE_MAPPING[flags.type];
+        if (flags['env-var']) {
+            configValue = {
+                provided: {
+                    lookup: flags['env-var'],
+                    source: ProvidedSource.EnvVar,
+                },
+            };
+        }
+        else {
+            const valueInput = await getValue({
+                desiredValue: flags.value,
+                flags,
+                message: 'Default value',
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                quonfig: undefined,
+            });
+            if (valueInput.ok) {
+                const rawValue = valueInput.value;
+                const parsedConfigValue = coerceIntoType(flags.type, rawValue);
+                if (!parsedConfigValue) {
+                    return this.err(`Failed to coerce value into type: ${flags.type}`, { key, phase: 'coercion' });
+                }
+                configValue = parsedConfigValue[0];
+                valueType = parsedConfigValue[1];
+                if (secret.selected) {
+                    const confidentialValueResult = await makeConfidentialValue(this, rawValue, secret, '');
+                    if (!confidentialValueResult.ok) {
+                        this.resultMessage(confidentialValueResult);
+                        return;
+                    }
+                    configValue = confidentialValueResult.value;
+                }
+            }
+            else {
+                return;
+            }
+        }
+        if (flags.confidential) {
+            configValue.confidential = true;
+        }
+        // Build oRPC input for configs/create
+        const createInput = {
+            workspaceId: this.workspaceId,
+            config: {
+                key: args.name,
+                valueType: mapValueTypeToString(valueType),
+                sendToClientSdk: false,
+                default: {
+                    rules: [
+                        {
+                            criteria: [],
+                            value: mapConfigValueToDto(configValue, valueType),
+                        },
+                    ],
+                },
+            },
+        };
+        this.verboseLog('RPC configs/create', createInput);
+        const request = await this.apiClient.post('/api/v1/configs/create', createInput);
+        if (!request.ok) {
+            const errMsg = request.status === 409
+                ? `Failed to create config: ${key} already exists`
+                : `Failed to create config: ${request.status} | ${JSON.stringify(request.error)}`;
+            return this.err(errMsg, { key, phase: 'creation', serverError: request.error });
+        }
+        const response = request.json;
+        const confidentialMaybe = flags.confidential ? '(confidential) ' : '';
+        return this.ok(`${checkmark} Created ${confidentialMaybe}config: ${key}`, { key, ...response });
+    }
+    async createBooleanFlag(args, rawDefault) {
+        const key = args.name;
+        const defaultValue = coerceBool(rawDefault ?? 'false');
+        // Build oRPC input for flags/create
+        const createInput = {
+            workspaceId: this.workspaceId,
+            flag: {
+                key,
+                valueType: 'bool',
+                sendToClientSdk: true,
+                variants: [
+                    {
+                        value: {
+                            type: 'bool',
+                            value: true,
+                        },
+                        name: 'True',
+                        description: 'Enabled',
+                    },
+                    {
+                        value: {
+                            type: 'bool',
+                            value: false,
+                        },
+                        name: 'False',
+                        description: 'Disabled',
+                    },
+                ],
+                default: {
+                    rules: [
+                        {
+                            criteria: [],
+                            value: {
+                                type: 'bool',
+                                value: defaultValue,
+                            },
+                        },
+                    ],
+                },
+            },
+        };
+        this.verboseLog('RPC flags/create', createInput);
+        const request = await this.apiClient.post('/api/v1/flags/create', createInput);
+        if (!request.ok) {
+            const errMsg = request.status === 409
+                ? `Failed to create boolean flag: ${key} already exists`
+                : `Failed to create boolean flag: ${request.status} | ${JSON.stringify(request.error)}`;
+            return this.err(errMsg, { key, phase: 'creation', serverError: request.error });
+        }
+        const response = request.json;
+        return this.ok(`${checkmark} Created boolean flag: ${key}`, { key, ...response });
+    }
+}

package/dist/commands/download.d.ts

@@ -0,0 +1,13 @@
+import type { JsonObj } from '../result.js';
+import { APICommand } from '../index.js';
+export default class Download extends APICommand {
+    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>;
+        'sdk-key': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    init(): Promise<void>;
+    run(): Promise<JsonObj | void>;
+    private writeFile;
+}

package/dist/commands/download.js

@@ -0,0 +1,63 @@
+import { Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { APICommand } from '../index.js';
+import { getProjectEnvFromSdkKey } from '@quonfig/node';
+import getEnvironment from '../ui/get-environment.js';
+import { checkmark } from '../util/color.js';
+import getClient from '../util/get-client.js';
+export default class Download extends APICommand {
+    static description = `Download a Datafile for a given environment
+
+  You can serve a datafile using the \`serve\` command.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --environment=test',
+        '<%= config.bin %> <%= command.id %> --environment=test --sdk-key=YOUR_SDK_KEY',
+    ];
+    static flags = {
+        environment: Flags.string({ description: 'environment to download' }),
+        'sdk-key': Flags.string({
+            description: 'SDK key for authentication (uses legacy download endpoint)',
+            required: false,
+        }),
+    };
+    async init() {
+        await super.init();
+        const { flags } = await this.parse(Download);
+        // If SDK key is provided, reinitialize the client with it
+        if (flags['sdk-key']) {
+            this.rawApiClient = await getClient(this, flags['sdk-key'], flags.profile);
+            this.currentEnvironment = getProjectEnvFromSdkKey(flags['sdk-key']);
+        }
+    }
+    async run() {
+        const { flags } = await this.parse(Download);
+        const environment = await getEnvironment({
+            command: this,
+            flags,
+            message: 'Which environment would you like to download?',
+            providedEnvironment: flags.environment,
+        });
+        if (!environment) {
+            return;
+        }
+        this.verboseLog({ environment, usingSdkKey: Boolean(flags['sdk-key']) });
+        // Use legacy endpoint if SDK key is provided, otherwise use new OAuth endpoint
+        const downloadUrl = flags['sdk-key']
+            ? `/api/v2/configs/download?envId=${environment.id}`
+            : `/all-config-types/v1/download?envId=${environment.id}`;
+        const download = await this.apiClient.get(downloadUrl);
+        if (download.ok) {
+            return this.writeFile(download, environment);
+        }
+        this.verboseLog({ result: download });
+        return this.err(`Failed to download file. Status=${download.status}`, download.error);
+    }
+    writeFile(result, environment) {
+        const fileName = `quonfig.${environment.name}.${environment.id}.config.json`;
+        const filePath = path.join(process.cwd(), fileName);
+        fs.writeFileSync(filePath, JSON.stringify(result.json, null, 2));
+        this.log(`${checkmark} Successfully downloaded ${fileName}`);
+        return { filePath, succes: true };
+    }
+}

package/dist/commands/generate-new-hex-key.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from '../index.js';
+import { JsonObj } from '../result.js';
+export default class GenerateNewHexKey extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<JsonObj | void>;
+}

package/dist/commands/generate-new-hex-key.js

@@ -0,0 +1,10 @@
+import { encryption } from '@quonfig/node';
+import { BaseCommand } from '../index.js';
+export default class GenerateNewHexKey extends BaseCommand {
+    static description = 'Generate a new hex key suitable for secrets';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const key = encryption.generateNewHexKey();
+        return this.ok(key, { key });
+    }
+}

package/dist/commands/generate.d.ts

@@ -0,0 +1,16 @@
+import type { JsonObj } from '../result.js';
+import { APICommand } from '../index.js';
+export default class Generate extends APICommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'output-directory': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        targets: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static summary: string;
+    run(): Promise<JsonObj | void>;
+    private generateParsedConfig;
+    private readLocalConfig;
+    private resolveGenerator;
+    private resolveLanguage;
+}