@quonfig/cli 0.0.1

package/dist/codegen/language-mappers/zod-base-mapper.js

@@ -0,0 +1,111 @@
+import * as introspect from '../zod-introspection.js';
+export class ZodBaseMapper {
+    resolveType(type) {
+        // Check for meta description first and allow implementers to handle it
+        const metaDescription = introspect.getMetaDescription(type);
+        if (metaDescription) {
+            const result = this.withMeta(metaDescription, () => this.resolveTypeInternal(type));
+            return result;
+        }
+        return this.resolveTypeInternal(type);
+    }
+    /**
+     * Hook for handling meta descriptions on schemas.
+     * By default, this just returns the resolved type without any modification.
+     * Subclasses can override this to add comments or other metadata handling.
+     *
+     * @param description The description from .meta({ description: "..." })
+     * @param resolveType A function that resolves the inner type
+     * @returns The type string, potentially with description metadata
+     */
+    withMeta(description, resolveType) {
+        // Default implementation: just return the resolved type
+        return resolveType();
+    }
+    resolveTypeInternal(type) {
+        if (introspect.isAny(type)) {
+            return this.any();
+        }
+        if (introspect.isArray(type)) {
+            const element = introspect.getArrayElement(type);
+            const internalType = this.resolveType(element);
+            return this.array(internalType);
+        }
+        if (introspect.isBoolean(type)) {
+            return this.boolean();
+        }
+        if (introspect.isDefault(type)) {
+            // Unwrap default to get the inner type
+            const { innerType } = introspect.unwrapDefault(type);
+            const internalType = this.resolveType(innerType);
+            return internalType;
+        }
+        if (introspect.isEnum(type)) {
+            const values = introspect.getEnumValues(type);
+            return this.enum(values);
+        }
+        if (introspect.isLiteral(type)) {
+            const value = introspect.getLiteralValue(type);
+            return this.literal(value);
+        }
+        if (introspect.isFunction(type)) {
+            const { args, returns } = introspect.getFunctionSignature(type);
+            const argsStr = this.functionArguments(args);
+            const returnsStr = this.functionReturns(returns);
+            return this.function(argsStr, returnsStr);
+        }
+        if (introspect.isNull(type)) {
+            return this.null();
+        }
+        if (introspect.isNullable(type)) {
+            // Handle nullable by unwrapping it
+            const innerType = introspect.unwrapNullable(type);
+            return this.union([this.resolveType(innerType), this.null()]);
+        }
+        if (introspect.isNumber(type)) {
+            const isInteger = introspect.isNumberInteger(type);
+            return this.number(isInteger);
+        }
+        if (introspect.isObject(type)) {
+            const shape = introspect.getObjectShape(type);
+            const props = Object.entries(shape);
+            return this.object(props);
+        }
+        if (introspect.isOptional(type)) {
+            const innerType = introspect.unwrapOptional(type);
+            const internalType = this.resolveType(innerType);
+            return this.optional(internalType);
+        }
+        if (introspect.isRecord(type)) {
+            const { keyType, valueType } = introspect.getRecordTypes(type);
+            const keyTypeStr = this.resolveType(keyType);
+            const valueTypeStr = this.resolveType(valueType);
+            return this.record(keyTypeStr, valueTypeStr);
+        }
+        if (introspect.isString(type)) {
+            return this.string();
+        }
+        if (introspect.isTuple(type)) {
+            const items = introspect.getTupleItems(type);
+            const itemsStr = items.map((item) => this.resolveType(item));
+            return this.tuple(itemsStr);
+        }
+        if (introspect.isUndefined(type)) {
+            return this.undefined();
+        }
+        if (introspect.isUnion(type)) {
+            const options = introspect.getUnionOptions(type);
+            const optionsStr = options.map((option) => this.resolveType(option));
+            return this.union(optionsStr);
+        }
+        if (introspect.isUnknown(type)) {
+            return this.unknown();
+        }
+        if (introspect.isNever(type)) {
+            return this.never();
+        }
+        console.warn(`Unknown zod type:`, type);
+        // If the type is not recognized, default to 'any'
+        return this.any();
+    }
+}

package/dist/codegen/language-mappers/zod-to-string-mapper.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { $ZodFunctionArgs, $ZodFunctionOut, util } from 'zod/v4/core';
+import { ZodBaseMapper } from './zod-base-mapper.js';
+export declare class ZodToStringMapper extends ZodBaseMapper {
+    any(): string;
+    array(wrappedType: string): string;
+    boolean(): string;
+    enum(values: util.EnumValue[]): string;
+    function(input: string, output: string): string;
+    functionArguments(value?: $ZodFunctionArgs): string;
+    functionReturns(value: $ZodFunctionOut): string;
+    null(): string;
+    literal(value: string | number | boolean | null): string;
+    number(isInteger?: boolean): "z.number()" | "z.number().int()";
+    object(properties: [string, z.ZodTypeAny][]): string;
+    optional(wrappedType: string): string;
+    never(): string;
+    record(keyType: string, valueType: string): string;
+    renderField(type: z.ZodTypeAny, key?: string): string;
+    string(): string;
+    tuple(wrappedTypes: string[]): string;
+    undefined(): string;
+    union(wrappedTypes: string[]): string;
+    unknown(): string;
+}

package/dist/codegen/language-mappers/zod-to-string-mapper.js

@@ -0,0 +1,87 @@
+import { ZodBaseMapper } from './zod-base-mapper.js';
+export class ZodToStringMapper extends ZodBaseMapper {
+    any() {
+        return 'z.any()';
+    }
+    array(wrappedType) {
+        return `z.array(${wrappedType})`;
+    }
+    boolean() {
+        return 'z.boolean()';
+    }
+    enum(values) {
+        return `z.enum([${values.map((v) => (typeof v === 'string' ? `'${v}'` : String(v))).join(',')}])`;
+    }
+    function(input, output) {
+        return `z.function({input: z.tuple([${input}]), output: ${output}})`;
+    }
+    functionArguments(value) {
+        if (!value) {
+            return '';
+        }
+        const def = value.def;
+        const items = def.items || [];
+        const args = items.map((item) => {
+            const mapper = new ZodToStringMapper();
+            return mapper.resolveType(item);
+        });
+        return args.join(', ');
+    }
+    functionReturns(value) {
+        const mapper = new ZodToStringMapper();
+        return mapper.resolveType(value);
+    }
+    null() {
+        return 'z.null()';
+    }
+    literal(value) {
+        return `z.literal(${JSON.stringify(value)})`;
+    }
+    number(isInteger = false) {
+        const base = 'z.number()';
+        if (isInteger) {
+            return `${base}.int()`;
+        }
+        return base;
+    }
+    object(properties) {
+        const props = properties
+            .map(([key, type]) => {
+            const mapper = new ZodToStringMapper();
+            return mapper.renderField(type, key);
+        })
+            .join('; ');
+        return `z.object({${props}})`;
+    }
+    optional(wrappedType) {
+        return `${wrappedType}.optional()`;
+    }
+    never() {
+        return 'z.never()';
+    }
+    record(keyType, valueType) {
+        return `z.record(${keyType}, ${valueType})`;
+    }
+    renderField(type, key) {
+        const resolved = this.resolveType(type);
+        if (key) {
+            return `${key}: ${resolved}`;
+        }
+        return resolved;
+    }
+    string() {
+        return 'z.string()';
+    }
+    tuple(wrappedTypes) {
+        return `z.tuple([${wrappedTypes.join(', ')}])`;
+    }
+    undefined() {
+        return 'z.undefined()';
+    }
+    union(wrappedTypes) {
+        return `z.union([${wrappedTypes.join(', ')}])`;
+    }
+    unknown() {
+        return 'z.unknown()';
+    }
+}

package/dist/codegen/language-mappers/zod-to-typescript-mapper.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { ZodTypeSupported } from '../types.js';
+import { ZodBaseMapper } from './zod-base-mapper.js';
+export type ZodToTypescriptMapperTarget = 'accessor' | 'raw';
+export declare class ZodToTypescriptMapper extends ZodBaseMapper {
+    private fieldName;
+    private metaDescription;
+    private optionalProperty;
+    private target;
+    constructor({ fieldName, target }?: {
+        fieldName?: string;
+        target?: ZodToTypescriptMapperTarget;
+    });
+    any(): string;
+    array(wrappedType: string): string;
+    boolean(): string;
+    enum(values: string[]): string;
+    function(args: string, returns: string): string;
+    functionArguments(value?: z.ZodTuple): string;
+    functionReturns(value: z.ZodTypeAny): string;
+    null(): string;
+    literal(value: string | number | boolean | null): string;
+    number(): string;
+    object(properties: [string, z.ZodTypeAny][]): string;
+    optional(wrappedType: string): string;
+    never(): string;
+    record(keyType: string, valueType: string): string;
+    renderField(type: ZodTypeSupported): string;
+    string(): string;
+    tuple(wrappedTypes: string[]): string;
+    undefined(): string;
+    union(wrappedTypes: string[]): string;
+    unknown(): string;
+    protected withMeta(description: string, resolveType: () => string): string;
+}

package/dist/codegen/language-mappers/zod-to-typescript-mapper.js

@@ -0,0 +1,133 @@
+import { ZodBaseMapper } from './zod-base-mapper.js';
+export class ZodToTypescriptMapper extends ZodBaseMapper {
+    fieldName;
+    metaDescription = undefined;
+    optionalProperty;
+    target;
+    constructor({ fieldName, target } = {}) {
+        super();
+        this.fieldName = fieldName;
+        this.optionalProperty = false;
+        this.target = target ?? 'accessor';
+    }
+    any() {
+        return 'any';
+    }
+    array(wrappedType) {
+        return `Array<${wrappedType}>`;
+    }
+    boolean() {
+        return 'boolean';
+    }
+    enum(values) {
+        return values.map((v) => `'${v}'`).join(' | ');
+    }
+    function(args, returns) {
+        // When in raw mode, we return a string type for functions,
+        // as this is what comes back from the server directly
+        if (this.target === 'raw') {
+            return 'string | undefined';
+        }
+        return `(...params: ${args}) => ${returns}`;
+    }
+    functionArguments(value) {
+        if (!value) {
+            return '';
+        }
+        const mapper = new ZodToTypescriptMapper();
+        return mapper.resolveType(value);
+    }
+    functionReturns(value) {
+        const mapper = new ZodToTypescriptMapper();
+        return mapper.resolveType(value);
+    }
+    null() {
+        return 'null';
+    }
+    literal(value) {
+        return JSON.stringify(value);
+    }
+    number() {
+        return 'number';
+    }
+    object(properties) {
+        const props = properties
+            .map(([fieldName, type]) => {
+            const mapper = new ZodToTypescriptMapper({ fieldName, target: this.target });
+            return mapper.renderField(type);
+        })
+            .join('; ');
+        return `{ ${props} }`;
+    }
+    optional(wrappedType) {
+        // In TypeScript, we hoist the optional flag  to the field definition when operating directly on a field
+        if (this.fieldName) {
+            this.optionalProperty = true;
+            return wrappedType;
+        }
+        // Fallback to a union type w/undefined for inline optional definitions
+        return this.union([wrappedType, 'undefined']);
+    }
+    never() {
+        return 'never';
+    }
+    record(keyType, valueType) {
+        return `Record<${keyType}, ${valueType}>`;
+    }
+    renderField(type) {
+        if (!this.fieldName) {
+            throw new Error('Field name must be set to render a field.');
+        }
+        // Must invoke resolveType to ensure the type is fully resolved,
+        // which always guarantees that the optional flag is set correctly.
+        const resolved = this.resolveType(type);
+        // If there's a meta description, add it as a comment before the field
+        let result = '';
+        if (this.metaDescription) {
+            // Check if the description contains newlines (multi-line JSON)
+            if (this.metaDescription.includes('\n')) {
+                // Format as a multi-line block comment
+                const lines = this.metaDescription.split('\n');
+                result += '/**\n';
+                for (const line of lines) {
+                    result += ` * ${line}\n`;
+                }
+                result += ' */ ';
+            }
+            else {
+                // Single line comment
+                result += `/** ${this.metaDescription} */ `;
+            }
+        }
+        result += `"${this.fieldName}"${this.optionalProperty ? '?' : ''}: ${resolved}`;
+        return result;
+    }
+    string() {
+        return 'string';
+    }
+    tuple(wrappedTypes) {
+        return `[${wrappedTypes.join(', ')}]`;
+    }
+    undefined() {
+        return 'undefined';
+    }
+    union(wrappedTypes) {
+        return wrappedTypes
+            .map((t) => {
+            // If the type includes an arrow function, we need to wrap it in parentheses
+            if (t.includes('=>')) {
+                return `(${t})`;
+            }
+            return t;
+        })
+            .join(' | ');
+    }
+    unknown() {
+        return 'unknown';
+    }
+    withMeta(description, resolveType) {
+        // Store the description to be used when rendering the field
+        this.metaDescription = description;
+        return resolveType();
+    }
+}

package/dist/codegen/language-mappers/zod-to-typescript-return-value-mapper.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { ZodTypeSupported } from '../types.js';
+import { ZodBaseMapper } from './zod-base-mapper.js';
+export declare class ZodToTypescriptReturnValueMapper extends ZodBaseMapper {
+    private fieldName;
+    private FUNCTION_ARGUMENTS_NAME;
+    private metaDescription;
+    private returnTypePropertyPath;
+    constructor({ fieldName, returnTypePropertyPath }?: {
+        fieldName?: string;
+        returnTypePropertyPath?: string[];
+    });
+    any(): string;
+    array(): string;
+    boolean(): string;
+    enum(): string;
+    function(args: string, returns: string): string;
+    functionArguments(value?: z.ZodTuple): string;
+    functionReturns(): string;
+    null(): string;
+    literal(): string;
+    number(): string;
+    object(properties: [string, z.ZodTypeAny][]): string;
+    optional(wrappedType: string): string;
+    never(): string;
+    record(): string;
+    renderField(type: ZodTypeSupported): string;
+    string(): string;
+    tuple(wrappedTypes: string[]): string;
+    undefined(): string;
+    union(wrappedTypes: string[]): string;
+    unknown(): string;
+    protected withMeta(description: string, resolveType: () => string): string;
+    private printPath;
+    private printPropertyPath;
+}

package/dist/codegen/language-mappers/zod-to-typescript-return-value-mapper.js

@@ -0,0 +1,150 @@
+import { ZodBaseMapper } from './zod-base-mapper.js';
+export class ZodToTypescriptReturnValueMapper extends ZodBaseMapper {
+    fieldName;
+    FUNCTION_ARGUMENTS_NAME = 'params';
+    metaDescription = undefined;
+    returnTypePropertyPath;
+    constructor({ fieldName, returnTypePropertyPath } = {}) {
+        super();
+        this.fieldName = fieldName;
+        this.returnTypePropertyPath = returnTypePropertyPath ?? [];
+    }
+    any() {
+        return `raw${this.printPropertyPath()}`;
+    }
+    array() {
+        // Explicity not supporting naviagtion into array items, as the number of items is not known at compile time
+        return `raw${this.printPath(this.returnTypePropertyPath)}`;
+    }
+    boolean() {
+        return `raw${this.printPropertyPath()}`;
+    }
+    enum() {
+        return `raw${this.printPropertyPath()}`;
+    }
+    function(args, returns) {
+        return `(${args}) => ${returns}`;
+    }
+    functionArguments(value) {
+        if (!value) {
+            return '';
+        }
+        // Everything is already typed, so return top level params object
+        return this.FUNCTION_ARGUMENTS_NAME;
+    }
+    // Mustache handles rendering of function values
+    functionReturns() {
+        return `Mustache.render(raw${this.printPropertyPath()} ?? "", ${this.FUNCTION_ARGUMENTS_NAME})`;
+    }
+    null() {
+        return `raw${this.printPropertyPath()}`;
+    }
+    literal() {
+        return `raw${this.printPropertyPath()}`;
+    }
+    number() {
+        return `raw${this.printPropertyPath()}`;
+    }
+    object(properties) {
+        const props = properties
+            .map(([fieldName, type]) => {
+            const mapper = new ZodToTypescriptReturnValueMapper({
+                fieldName,
+                returnTypePropertyPath: [...this.returnTypePropertyPath, fieldName],
+            });
+            return mapper.renderField(type);
+        })
+            .join(', ');
+        return `{ ${props} }`;
+    }
+    optional(wrappedType) {
+        // In TypeScript, we hoist the optional flag  to the field definition when operating directly on a field
+        if (this.fieldName) {
+            return wrappedType;
+        }
+        // Fallback to a union type w/undefined for inline optional definitions
+        return this.union([wrappedType, 'undefined']);
+    }
+    never() {
+        return `raw${this.printPropertyPath()}`;
+    }
+    record() {
+        // Explicitly not supporting navigation into record values, as the keys are not known at compile time
+        return `raw${this.printPath(this.returnTypePropertyPath)}`;
+    }
+    renderField(type) {
+        if (!this.fieldName) {
+            throw new Error('Field name must be set in the resolution context to render a field.');
+        }
+        // Must invoke resolveType to ensure the type is fully resolved,
+        // which always guarantees that the optional flag is set correctly.
+        const resolved = this.resolveType(type);
+        // If there's a meta description, add it as a comment before the field
+        let result = '';
+        if (this.metaDescription) {
+            // Check if the description contains newlines (multi-line JSON)
+            if (this.metaDescription.includes('\n')) {
+                // Format as a multi-line block comment
+                const lines = this.metaDescription.split('\n');
+                result += '/**\n';
+                for (const line of lines) {
+                    result += ` * ${line}\n`;
+                }
+                result += ' */ ';
+            }
+            else {
+                // Single line comment
+                result += `/** ${this.metaDescription} */ `;
+            }
+        }
+        result += `"${this.fieldName}": ${resolved}`;
+        // Clear metaDescription to prevent it from leaking into subsequent renderField calls
+        this.metaDescription = undefined;
+        return result;
+    }
+    string() {
+        return `raw${this.printPropertyPath()}`;
+    }
+    tuple(wrappedTypes) {
+        const tupleNavigation = wrappedTypes.map((wt, index) => {
+            let massagedWrappedType = wt;
+            if (massagedWrappedType !== 'raw') {
+                // Remove trailing ! from the wrapped type
+                massagedWrappedType = massagedWrappedType.replace(/!$/, '');
+            }
+            return `${massagedWrappedType}?.[${index}]!`;
+        });
+        return `[${tupleNavigation.join(`, `)}]`;
+    }
+    undefined() {
+        return `raw${this.printPropertyPath()}`;
+    }
+    union(wrappedTypes) {
+        // If we have functions in the union, force the return type to be a function type
+        const functionWrappedTypes = wrappedTypes.filter((t) => t.includes('=>'));
+        if (functionWrappedTypes.length > 0) {
+            return functionWrappedTypes[0];
+        }
+        return `raw${this.printPropertyPath()}`;
+    }
+    unknown() {
+        return `raw${this.printPropertyPath()}`;
+    }
+    withMeta(description, resolveType) {
+        // Store the description to be used when rendering the field
+        this.metaDescription = description;
+        return resolveType();
+    }
+    printPath(paths) {
+        if (paths.length === 0) {
+            return '';
+        }
+        // Always safe navigate the path to ensure we don't throw an error if the property doesn't exist
+        const path = paths.reduce((acc, part) => `${acc}?.['${part}']`, '');
+        // To satisfy TypeScript's type system, tell it the value is always defined
+        return `${path}!`;
+    }
+    printPropertyPath() {
+        return this.printPath(this.returnTypePropertyPath);
+    }
+}

package/dist/codegen/mustache-extractor.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare class MustacheExtractor {
+    static extractSchema(template: string, log: (category: string | unknown, message?: unknown) => void): z.ZodObject<Record<string, z.ZodTypeAny>>;
+    private static generateZodSchema;
+    private static parseMustacheTemplate;
+}

package/dist/codegen/mustache-extractor.js

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+// Extracts a zod schema from a mustache template.
+// eg "Hello {{name}}!" -> z.object({ name: z.string() })
+export class MustacheExtractor {
+    static extractSchema(template, log) {
+        if (!template) {
+            return z.object({});
+        }
+        const nodes = this.parseMustacheTemplate(template, log);
+        return this.generateZodSchema(nodes);
+    }
+    static generateZodSchema(nodes) {
+        const properties = {};
+        for (const node of nodes) {
+            if (node.isSection) {
+                if (node.children.length > 0) {
+                    const childSchema = this.generateZodSchema(node.children);
+                    properties[node.name] = node.isInverted ? childSchema.optional() : z.array(childSchema);
+                }
+                else {
+                    properties[node.name] = node.isInverted ? z.boolean().optional() : z.boolean();
+                }
+            }
+            else if (!properties[node.name]) {
+                properties[node.name] = z.string();
+            }
+        }
+        return z.object(properties);
+    }
+    static parseMustacheTemplate(template, log) {
+        const tokens = template.match(/{{[^}]+}}|[^{}]+/g) || [];
+        const root = [];
+        const stack = [root];
+        for (const token of tokens) {
+            if (!token.startsWith('{{'))
+                continue;
+            const content = token.slice(2, -2).trim();
+            // Add check for partials
+            if (content.startsWith('>')) {
+                log(`Found Mustache partial: ${content.slice(1)}`);
+                continue;
+            }
+            if (content.startsWith('#')) {
+                // Section start
+                const name = content.slice(1);
+                const newSection = {
+                    children: [],
+                    isInverted: false,
+                    isSection: true,
+                    name,
+                };
+                stack.at(-1).push(newSection);
+                stack.push(newSection.children);
+            }
+            else if (content.startsWith('^')) {
+                // Inverted section
+                const name = content.slice(1);
+                const newSection = {
+                    children: [],
+                    isInverted: true,
+                    isSection: true,
+                    name,
+                };
+                stack.at(-1).push(newSection);
+                stack.push(newSection.children);
+            }
+            else if (content.startsWith('/')) {
+                // Section end
+                stack.pop();
+            }
+            else {
+                // Regular variable
+                stack.at(-1).push({
+                    children: [],
+                    isInverted: false,
+                    isSection: false,
+                    name: content,
+                });
+            }
+        }
+        return root;
+    }
+}