@bagelink/vue 1.4.42 → 1.4.46

package/bin/generateFormSchema.ts

@@ -0,0 +1,1038 @@
+#!/usr/bin/env node
+
+import type {
+	OpenAPIObject,
+	SchemaObject,
+	ReferenceObject,
+} from '@bagelink/sdk'
+import type {
+	ArrayBagelField,
+	ArrayFieldVal,
+	BaseBagelField,
+	BglFormSchemaT,
+	Path,
+	TextInputOptions,
+} from '@bagelink/vue'
+import { existsSync, mkdirSync } from 'node:fs'
+import path from 'node:path'
+import { argv, cwd, exit } from 'node:process'
+import { isSchemaObject, isReferenceObject } from '@bagelink/sdk'
+import { fmtDate, useForm } from '@bagelink/vue'
+import axios from 'axios'
+import { toValue } from 'vue'
+import {
+	formatAndWriteCode,
+	runEsLintOnDir,
+	parseConfig,
+	validateConfig,
+	printHelp,
+} from './utils'
+
+// =============================================================================
+// FORM UTILITIES (TOP-LEVEL SCOPE)
+// =============================================================================
+
+const {
+	txtField,
+	emailField,
+	dateField,
+	selectField,
+	telField,
+	numField,
+	arrField,
+	checkField,
+} = useForm()
+
+// =============================================================================
+// TYPES & INTERFACES
+// =============================================================================
+
+interface FieldOptions {
+	readonly helptext?: string
+	readonly required: boolean
+}
+
+interface GeneratorConfig {
+	readonly genSchemaId: string
+	readonly output: string
+	readonly url: string
+	readonly useUtilityFunctions?: boolean
+	readonly useTableSchema?: boolean
+	readonly verbose?: boolean
+}
+
+interface SchemaContext {
+	readonly openApiSchema: OpenAPIObject
+}
+
+type FormSchema<T> = BglFormSchemaT<T>
+let USING_FMT_DATE = false
+let USING_VERBOSE_FLAG = false
+
+function logVerbose(...args: any[]): void {
+	if (USING_VERBOSE_FLAG) {
+		console.log('🔍', ...args)
+	}
+}
+
+// =============================================================================
+// CONFIGURATION
+// =============================================================================
+
+function parseConfiguration(): GeneratorConfig {
+	const config = parseConfig({
+		schemaId: undefined,
+		defaultOutputFile: 'src/generated/exampleFormSchema.ts',
+		allowedFlags: ['utility-functions', 'table-schema', 'help', 'verbose'],
+	})
+
+	if (argv.includes('--help') || argv.includes('-h')) {
+		printHelp('generateFormSchema')
+		exit(0)
+	}
+
+	try {
+		validateConfig(config, ['baseUrl', 'schemaId'])
+	} catch (error: any) {
+		console.error('❌', error?.message)
+		exit(1)
+	}
+
+	USING_VERBOSE_FLAG = config.verbose || false
+
+	return {
+		genSchemaId: config.schemaId || '',
+		output: config.outputFile || 'src/generated/exampleFormSchema.ts',
+		url: `${config.baseUrl}/openapi.json`,
+		useUtilityFunctions: config.useUtilityFunctions,
+		useTableSchema: config.useTableSchema,
+	} as const
+}
+
+// =============================================================================
+// SCHEMA UTILITIES
+// =============================================================================
+
+function resolveSchemaReference(
+	schemaOrRef: SchemaObject | ReferenceObject,
+	openApiSchema: OpenAPIObject,
+	visitedRefs = new Set<string>()
+): SchemaObject | undefined {
+	if (!isReferenceObject(schemaOrRef)) {
+		return isSchemaObject(schemaOrRef) ? schemaOrRef : undefined
+	}
+
+	const refPath = schemaOrRef.$ref
+	if (visitedRefs.has(refPath)) {
+		logVerbose(`Circular reference detected: ${refPath}`)
+		return undefined
+	}
+
+	const refName = refPath.split('/').pop()
+	if (!refName || !openApiSchema.components?.schemas?.[refName]) {
+		logVerbose(`Could not resolve reference: ${refPath}`)
+		return undefined
+	}
+
+	const resolvedSchema = openApiSchema.components.schemas[refName]
+	if (isReferenceObject(resolvedSchema)) {
+		visitedRefs.add(refPath)
+		return resolveSchemaReference(resolvedSchema, openApiSchema, visitedRefs)
+	}
+
+	return isSchemaObject(resolvedSchema) ? resolvedSchema : undefined
+}
+
+function getSchemaById(
+	schemaId: string,
+	openApiSchema: OpenAPIObject
+): SchemaObject | undefined {
+	const schemaOrRef = openApiSchema.components?.schemas?.[schemaId]
+	return schemaOrRef
+		? resolveSchemaReference(schemaOrRef, openApiSchema)
+		: undefined
+}
+
+/**
+ * Resolves a schema reference and returns the actual schema object
+ */
+function resolveFieldSchema(
+	fieldSchema: SchemaObject | ReferenceObject,
+	openApiSchema: OpenAPIObject
+): SchemaObject | undefined {
+	if (isReferenceObject(fieldSchema)) {
+		return resolveSchemaReference(fieldSchema, openApiSchema)
+	}
+	return isSchemaObject(fieldSchema) ? fieldSchema : undefined
+}
+
+/**
+ * Gets the property schema for a nested field path
+ */
+function getNestedPropertySchema(
+	fieldPath: string[],
+	targetSchema: SchemaObject,
+	openApiSchema: OpenAPIObject
+): SchemaObject | undefined {
+	if (fieldPath.length === 0) return targetSchema
+
+	const [currentProp, ...remainingPath] = fieldPath
+	const currentProperty = targetSchema.properties?.[currentProp]
+
+	if (!currentProperty) {
+		logVerbose(`Property '${currentProp}' not found in schema`)
+		return undefined
+	}
+
+	const resolvedProperty = resolveFieldSchema(
+		currentProperty,
+		openApiSchema
+	)
+	if (!resolvedProperty) {
+		logVerbose(`Could not resolve property '${currentProp}'`)
+		return undefined
+	}
+
+	// If there are more path segments, continue resolving
+	if (remainingPath.length > 0) {
+		if (resolvedProperty.type === 'object' && resolvedProperty.properties) {
+			return getNestedPropertySchema(
+				remainingPath,
+				resolvedProperty,
+				openApiSchema
+			)
+		}
+		logVerbose(
+			`Cannot resolve nested path beyond '${currentProp}' - not an object type`
+		)
+		return undefined
+	}
+
+	return resolvedProperty
+}
+
+// =============================================================================
+// STRING FORMATTING
+// =============================================================================
+
+function formatPropertyName(name: string): string {
+	return name
+		.replace(/([A-Z])/g, ' $1')
+		.replace(/_/g, ' ')
+		.replace(/^\w/, c => c.toUpperCase())
+		.trim()
+}
+
+function formatTypeName(name: string): string {
+	return name
+		.replace(/_([a-z])/g, (_, letter: string) => letter.toUpperCase())
+		.replace(/^\w/, c => c.toUpperCase())
+		.replace(/\s+(\w)/g, (_, letter: string) => letter.toUpperCase())
+}
+
+function getHtmlInputType(format?: string): string | undefined {
+	const formatMap: Record<string, string> = {
+		'date': 'date',
+		'date-time': 'datetime-local',
+		'email': 'email',
+		'phone': 'tel',
+		'password': 'password',
+		'binary': 'file',
+		'uri': 'url',
+		'double': 'number',
+		'float': 'number',
+		'int32': 'number',
+		'int64': 'number',
+	}
+
+	return format ? formatMap[format] : undefined
+}
+
+// =============================================================================
+// FIELD CREATION
+// =============================================================================
+
+function createStringField<T>(
+	propName: Path<T>,
+	schema: SchemaObject,
+	options: FieldOptions
+): BaseBagelField<T, Path<T>> {
+	const label = formatPropertyName(propName as string)
+
+	// Email fields
+	if (schema.format === 'email') {
+		return emailField(propName, label, {
+			required: options.required,
+			placeholder: options.helptext,
+		})
+	}
+
+	// Date fields
+	if (schema.format === 'date' || schema.format === 'date-time') {
+		return dateField<T, Path<T>>(propName, label, {
+			required: options.required,
+			placeholder: options.helptext,
+			enableTime: schema.format === 'date-time',
+		})
+	}
+
+	// Phone fields
+	if (schema.format === 'phone') {
+		return telField<T, Path<T>>(propName, label, {
+			required: options.required,
+			placeholder: options.helptext,
+		})
+	}
+
+	// Enum fields as select
+	if (schema.enum?.length) {
+		const selectOptions = schema.enum.map(value => ({
+			label: String(value)
+				.replace(/_/g, ' ')
+				.replace(/\b\w/g, l => l.toUpperCase()),
+			value,
+		}))
+		return selectField<T, Path<T>>(propName, label, selectOptions, {
+			required: options.required,
+			placeholder: options.helptext,
+		})
+	}
+
+	// Default text field
+	const textOptions: TextInputOptions<T, Path<T>> = {
+		required: options.required,
+		helptext: options.helptext,
+		multiline: (schema.maxLength ?? 0) > 255,
+		pattern: schema.pattern,
+		type: getHtmlInputType(schema.format),
+	}
+
+	return txtField<T, Path<T>>(propName, label, textOptions)
+}
+
+function createNumberField<T>(
+	propName: Path<T>,
+	schema: SchemaObject,
+	options: FieldOptions
+): BaseBagelField<T, Path<T>> {
+	return numField<T, Path<T>>(
+		propName,
+		formatPropertyName(propName as string),
+		{
+			required: options.required,
+			placeholder: options.helptext,
+			min: schema.minimum,
+			max: schema.maximum,
+			step: schema.type === 'integer' ? 1 : undefined,
+		}
+	)
+}
+
+function createBooleanField<T>(
+	propName: Path<T>,
+	options: FieldOptions
+): BaseBagelField<T, Path<T>> {
+	return checkField(propName, formatPropertyName(propName as string), {
+		required: options.required,
+	})
+}
+
+function createArrayField<T>(
+	propName: Path<T>,
+	schema: SchemaObject,
+	options: FieldOptions,
+	schemaType: string,
+	context: SchemaContext
+): BaseBagelField<T, Path<T>> {
+	if (!schema.items) {
+		logVerbose(`Array field '${propName as string}' has no items schema`)
+		return createFallbackField(propName, options)
+	}
+
+	const itemsSchema = resolveSchemaReference(
+		schema.items,
+		context.openApiSchema
+	)
+	if (!itemsSchema) {
+		logVerbose(
+			`Array field '${propName as string}' has unresolvable items schema`
+		)
+		return createFallbackField(propName, options)
+	}
+
+	// Object array
+	if (itemsSchema.type === 'object' && itemsSchema.properties) {
+		const nestedSchema = convertSchemaToForm(
+			itemsSchema,
+			`${schemaType}Item`,
+			context
+		) as FormSchema<ArrayFieldVal<T, Path<T>>>
+
+		return arrField<T, Path<T>>(
+			propName,
+			formatPropertyName(propName as string),
+			nestedSchema
+		)
+	}
+
+	// Primitive array
+	const arrayType
+		= itemsSchema.type === 'number' || itemsSchema.type === 'integer'
+			? 'number'
+			: 'text'
+	return arrField<T, Path<T>>(
+		propName,
+		formatPropertyName(propName as string),
+		arrayType
+	)
+}
+
+function createFallbackField<T>(
+	propName: Path<T>,
+	options: FieldOptions
+): BaseBagelField<T, Path<T>> {
+	return txtField<T, Path<T>>(
+		propName,
+		formatPropertyName(propName as string),
+		{
+			required: options.required,
+			placeholder: options.helptext,
+		}
+	)
+}
+
+function createFieldByType<T>(
+	propName: Path<T>,
+	schema: SchemaObject,
+	options: FieldOptions,
+	schemaType: string,
+	context: SchemaContext
+): BaseBagelField<T, Path<T>> | null {
+	// Handle nullable union types
+	const actualSchema = getNonNullSchema(schema) || schema
+
+	switch (actualSchema.type) {
+		case 'string':
+			return createStringField(propName, actualSchema, options)
+		case 'number':
+		case 'integer':
+			return createNumberField(propName, actualSchema, options)
+		case 'boolean':
+			return createBooleanField(propName, options)
+		case 'array':
+			return createArrayField(
+				propName,
+				actualSchema,
+				options,
+				schemaType,
+				context
+			)
+		case 'object':
+			return null // Will be handled separately for flattening
+		default:
+			logVerbose(
+				`Unknown type '${actualSchema.type}' for field '${propName as string}', using fallback`
+			)
+			return createFallbackField(propName, options)
+	}
+}
+
+function getNonNullSchema(schema: SchemaObject): SchemaObject | undefined {
+	// Handle anyOf union types
+	if (schema.anyOf && Array.isArray(schema.anyOf)) {
+		const nonNullSchema = schema.anyOf.find((subSchema) => {
+			if (isReferenceObject(subSchema)) {
+				// We'd need to resolve this, but for simplicity, assume it's not null
+				return true
+			}
+			return subSchema.type !== 'null'
+		})
+
+		return nonNullSchema && !isReferenceObject(nonNullSchema)
+			? nonNullSchema
+			: undefined
+	}
+
+	// Handle oneOf union types
+	if (schema.oneOf && Array.isArray(schema.oneOf)) {
+		const nonNullSchema = schema.oneOf.find((subSchema) => {
+			if (isReferenceObject(subSchema)) {
+				return true
+			}
+			return subSchema.type !== 'null'
+		})
+
+		return nonNullSchema && !isReferenceObject(nonNullSchema)
+			? nonNullSchema
+			: undefined
+	}
+
+	return undefined
+}
+
+function processObjectField<T>(
+	propName: Path<T>,
+	schema: SchemaObject,
+	schemaType: string,
+	formSchema: FormSchema<T>,
+	context: SchemaContext
+): void {
+	if (!schema.properties || Object.keys(schema.properties).length === 0) return
+
+	logVerbose(`Creating nested fields for object: ${propName as string}`)
+	const nestedSchema = convertSchemaToForm(
+		schema,
+		`${schemaType}${formatTypeName(propName as string)}`,
+		context
+	)
+
+	// Flatten nested fields with proper namespacing
+	nestedSchema.forEach((subField) => {
+		if (!subField.id) return
+
+		const nestedField = {
+			...subField,
+			id: `${propName as string}.${subField.id}` as Path<T>,
+		}
+		formSchema.push(nestedField as FormSchema<T>[number])
+		logVerbose(`Added nested field: ${propName as string}.${subField.id}`)
+	})
+}
+
+// =============================================================================
+// SCHEMA CONVERSION
+// =============================================================================
+
+function convertSchemaToForm<T = Record<string, unknown>>(
+	schema: SchemaObject,
+	schemaType: string,
+	context: SchemaContext
+): FormSchema<T> {
+	const propertyKeys = Object.keys(schema.properties ?? {})
+	logVerbose(`Processing schema for ${schemaType}:`, propertyKeys)
+
+	if (!schema.properties) {
+		logVerbose('Schema has no properties')
+		return []
+	}
+
+	const formSchema: FormSchema<T> = []
+	const requiredFields = Array.isArray(schema.required) ? schema.required : []
+
+	Object.entries(schema.properties).forEach(([propName, propSchemaOrRef]) => {
+		const resolvedPropSchema = resolveSchemaReference(
+			propSchemaOrRef,
+			context.openApiSchema
+		)
+		if (!resolvedPropSchema) {
+			logVerbose(`Skipping unresolvable property: ${propName}`)
+			return
+		}
+
+		const fieldOptions: FieldOptions = {
+			required: requiredFields.includes(propName),
+			helptext: resolvedPropSchema.description,
+		}
+
+		logVerbose(
+			`Processing field: ${propName}, type: ${resolvedPropSchema.type ?? 'undefined'}, format: ${resolvedPropSchema.format ?? 'undefined'}`
+		)
+
+		// Handle object fields by flattening
+		if (resolvedPropSchema.type === 'object') {
+			processObjectField(
+				propName as Path<T>,
+				resolvedPropSchema,
+				schemaType,
+				formSchema,
+				context
+			)
+			return
+		}
+
+		const field = createFieldByType(
+			propName as Path<T>,
+			resolvedPropSchema,
+			fieldOptions,
+			schemaType,
+			context
+		)
+		if (!field) return
+
+		// Apply default value if specified
+		if (resolvedPropSchema.default !== undefined) {
+			field.defaultValue = resolvedPropSchema.default
+		}
+
+		formSchema.push(field as FormSchema<T>[number])
+		logVerbose(`Added field: ${propName} with $el: ${field.$el}`)
+	})
+
+	logVerbose(`Generated ${formSchema.length} fields for ${schemaType}`)
+	return formSchema
+}
+
+// =============================================================================
+// API OPERATIONS
+// =============================================================================
+
+async function fetchOpenApiSchema(url: string): Promise<OpenAPIObject> {
+	try {
+		const basicAuthHeader = {
+			Authorization: 'Basic YmFnZWxfdXNlcm5hbWU6Tm90U2VjdXJlQGJhZ2Vs',
+		}
+		const { data } = await axios.get<OpenAPIObject>(url, {
+			headers: basicAuthHeader,
+			timeout: 10000,
+		})
+		return data
+	} catch (error) {
+		console.error('🚨 Failed to fetch OpenAPI schema:', error)
+		const message = error instanceof Error ? error.message : 'Unknown error'
+		throw new Error(`Failed to fetch OpenAPI schema: ${message}`)
+	}
+}
+
+// =============================================================================
+// TABLE SCHEMA CONVERSION
+// =============================================================================
+
+function addTransformForType(
+	field: BaseBagelField<any, any>,
+	schemaType: string,
+	format?: string
+): void {
+	switch (schemaType) {
+		case 'boolean':
+			field.transform = (value: any) => {
+				if (value === true) return 'Yes'
+				if (value === false) return 'No'
+				return value
+			}
+			field.class = (value: any) => `pill ${value === true ? 'green' : 'light'}`
+			break
+
+		case 'string':
+			if (format === 'date' || format === 'date-time') {
+				USING_FMT_DATE = true
+				field.transform = (value: any) => fmtDate(value, { fmt: 'YYYY-MM-DD' })
+			} else if (format === 'email') {
+				field.attrs = { ...field.attrs, dir: 'ltr' }
+			} else if (format === 'phone') {
+				field.attrs = { ...field.attrs, dir: 'ltr' }
+			} else if (format === 'uri' || format === 'url') {
+				field.attrs = { ...field.attrs, dir: 'ltr' }
+			}
+			break
+
+		case 'number':
+		case 'integer':
+			field.transform = (value: any) => Number.isNaN(value) ? '' : value?.toLocaleString()
+			field.attrs = { ...field.attrs, dir: 'ltr' }
+			break
+
+		case 'array':
+			field.transform = (value: any) => {
+				if (!Array.isArray(value) || value.length === 0) return ''
+				if (typeof value[0] === 'object') return `${value.length} items`
+				return value.join(', ')
+			}
+			field.attrs = { ...field.attrs, dir: 'ltr' }
+			break
+
+		case 'object':
+			field.transform = (value: any) => {
+				if (!value || typeof value !== 'object') return ''
+				return 'Object'
+			}
+			break
+
+		default:
+			// Default string handling
+			break
+	}
+}
+
+/**
+ * Adds fallback transform based on field element type
+ */
+function addFallbackTransform<T>(
+	tableField: BaseBagelField<T, Path<T>>,
+	fieldElementType: string | undefined
+): void {
+	switch (fieldElementType) {
+		case 'date':
+			USING_FMT_DATE = true
+			tableField.transform = (value: any) => fmtDate(value, { fmt: 'YYYY-MM-DD' })
+			break
+
+		case 'check':
+			tableField.transform = (value: unknown) => value === true ? 'Yes' : value === false ? 'No' : value
+			tableField.class = (value: unknown) => `pill ${value === true ? 'green' : 'light'}`
+			break
+
+		case 'email':
+			tableField.attrs = { ...tableField.attrs, dir: 'ltr' }
+			break
+
+		case 'tel':
+			tableField.attrs = { ...tableField.attrs, dir: 'ltr' }
+			break
+
+		case 'number':
+			tableField.transform = (value: any) => {
+				if (value === null || value === undefined) return ''
+				return Number(value).toLocaleString()
+			}
+			tableField.attrs = { ...tableField.attrs, dir: 'ltr' }
+	}
+}
+
+function processFieldForTable<T>(
+	field: BaseBagelField<T, Path<T>>,
+	targetSchema: SchemaObject,
+	openApiSchema: OpenAPIObject
+): BaseBagelField<T, Path<T>> | undefined {
+	if (!field.id) return undefined
+
+	const fieldPath = field.id.toString().split('.')
+	const resolvedFieldSchema = getNestedPropertySchema(
+		fieldPath,
+		targetSchema,
+		openApiSchema
+	)
+
+	if (!resolvedFieldSchema) {
+		logVerbose(`No schema found for field: ${field.id}`)
+		return undefined
+	}
+
+	const tableField: BaseBagelField<T, Path<T>> = {
+		id: field.id,
+		label: field.label,
+		attrs: {},
+	}
+
+	// Handle union types (anyOf) - extract the non-null type
+	const actualSchema
+		= getNonNullSchema(resolvedFieldSchema) || resolvedFieldSchema
+
+	// Safely extract the schema type as a string
+	const schemaType = getSchemaTypeAsString(actualSchema.type)
+	addTransformForType(tableField, schemaType, actualSchema.format)
+
+	// Handle fallback based on original field element type
+	if (!tableField.transform) {
+		addFallbackTransform(tableField, field.$el)
+	}
+
+	return tableField
+}
+
+/**
+ * Safely converts schema type to string, handling arrays and undefined values
+ */
+function getSchemaTypeAsString(type: SchemaObject['type']): string {
+	if (Array.isArray(type)) {
+		// For arrays of types, prefer non-null types or return the first one
+		const nonNullType = type.find(t => t !== 'null' && t !== 'undefined')
+		return nonNullType || type[0] || 'string'
+	}
+	return type || 'string'
+}
+
+function convertToTableSchema<T = Record<string, unknown>>(
+	formSchema: FormSchema<T>,
+	targetSchema: SchemaObject,
+	openApiSchema: OpenAPIObject
+): FormSchema<T> {
+	const tableSchema: FormSchema<T> = []
+
+	formSchema.forEach((field) => {
+		const processedField = processFieldForTable(
+			field,
+			targetSchema,
+			openApiSchema
+		)
+		if (processedField) {
+			tableSchema.push(processedField)
+		}
+	})
+
+	logVerbose(
+		`Converted ${formSchema.length} form fields to ${tableSchema.length} table fields`
+	)
+	return tableSchema
+}
+
+// =============================================================================
+// CODE GENERATION
+// =============================================================================
+
+function cleanOptions(options: Record<string, any>): string {
+	if (!options || typeof options !== 'object') return '{}'
+
+	const cleaned: Record<string, any> = {}
+	const skipDefaults = ['step', 'enableTime', 'multiline', 'required']
+
+	Object.entries(options).forEach(([key, value]) => {
+		const shouldSkip
+			= value === undefined
+				|| value === null
+				|| value === false
+				|| value === ''
+				|| value === 0
+				|| (skipDefaults.includes(key) && (value === 1 || value === false))
+				|| (key === 'attrs'
+					&& typeof value === 'object'
+					&& Object.keys(value).length === 0)
+
+		if (!shouldSkip) {
+			cleaned[key] = value
+		}
+	})
+
+	return Object.keys(cleaned).length > 0 ? JSON.stringify(cleaned) : '{}'
+}
+
+function extractFieldOptions<T>(field: BaseBagelField<T, Path<T>>) {
+	const fieldProps = [
+		'required',
+		'placeholder',
+		'helptext',
+		'defaultValue',
+		'class',
+		'disabled',
+		'vIf',
+		'transform',
+		'onUpdate',
+		'validate',
+	] as const
+
+	type OptFieldProps = typeof fieldProps[number] | (string & {})
+	const options: Partial<Record<OptFieldProps, any>> = {}
+
+	fieldProps.forEach((prop) => {
+		if (field[prop] !== undefined) {
+			options[prop] = field[prop]
+		}
+	})
+
+	if (field.attrs && typeof field.attrs === 'object') {
+		Object.entries(field.attrs).forEach(([key, value]) => {
+			if (value !== undefined && value !== null) {
+				options[key] = value
+			}
+		})
+	}
+
+	return options
+}
+
+function generateFieldCall<T>(field: BaseBagelField<T, Path<T>>, useTableSchema: boolean): string {
+	const fieldId = field.id as string
+	const fieldLabel = field.label || formatPropertyName(fieldId)
+	const fieldOptions = extractFieldOptions(field)
+	const cleanedOptions = cleanOptions(fieldOptions)
+
+	if (useTableSchema) {
+		const options: string[] = []
+		const specialProps = ['transform', 'class', 'attrs'] as const
+
+		specialProps.forEach((prop) => {
+			if (field[prop]) {
+				const value = prop === 'attrs'
+					? JSON.stringify(field[prop])
+					: field[prop].toString()
+				options.push(`${prop}: ${value}`)
+			}
+		})
+
+		const optionsStr = options.length > 0 ? `{ ${options.join(', ')} }` : ''
+		return `getBaseField('${fieldId}', '${fieldLabel}'${optionsStr ? `, ${optionsStr}` : ''})`
+	}
+
+	const fieldTypeMap: Record<string, string> = {
+		text: 'txtField',
+		email: 'emailField',
+		date: 'dateField',
+		tel: 'telField',
+		number: 'numField',
+		check: 'checkField',
+		checkbox: 'checkField',
+	}
+
+	const fieldType = fieldTypeMap[field.$el] || 'txtField'
+
+	if (field.$el === 'select') {
+		const selectOptions
+			= field.options || (field.attrs && field.attrs.options) || []
+		const optionsStr = JSON.stringify(selectOptions)
+		return `selectField('${fieldId}', '${fieldLabel}', ${optionsStr}, ${cleanedOptions})`
+	}
+
+	if (field.$el === 'array') {
+		const arrayField = field as ArrayBagelField<any, any>
+		if (arrayField.attrs?.schema) {
+			const nestedCalls = toValue(arrayField.attrs.schema).map(
+				(nestedField: any) => generateFieldCall(nestedField, useTableSchema)
+			)
+			const nestedSchemaStr = `[${nestedCalls.join(',')}]`
+			return `arrField('${fieldId}', '${fieldLabel}', ${nestedSchemaStr})`
+		}
+		const arrayType = arrayField.attrs?.type || 'text'
+		return `arrField('${fieldId}', '${fieldLabel}', '${arrayType}')`
+	}
+
+	return `${fieldType}('${fieldId}', '${fieldLabel}', ${cleanedOptions})`
+}
+
+function generateCodeWithUtilities<T>(
+	schemaId: string,
+	formSchema: FormSchema<T>,
+	config: GeneratorConfig
+): string {
+	const imports = new Set<string>()
+	const fieldCalls: string[] = []
+
+	formSchema.forEach((field) => {
+		const call = generateFieldCall(field, config.useTableSchema || false)
+		fieldCalls.push(call)
+
+		// Extract import from function call
+		const functionName = call.split('(')[0]
+		imports.add(functionName)
+	})
+
+	if (config.useTableSchema) {
+		imports.add('getBaseField')
+	}
+
+	const importList = Array.from(imports).sort().join(', ')
+	const importStatement
+		= imports.size > 0 ? `const { ${importList} } = useForm()` : ''
+
+	return `import type { BglFormSchemaT } from '@bagelink/vue'
+import type { ${schemaId} } from '@/client/types'
+import { useForm ${USING_FMT_DATE ? ', fmtDate' : ''} } from '@bagelink/vue'
+
+${importStatement}
+
+/**
+ * Generated form schema for ${schemaId}
+ */
+export function generate${schemaId}FormSchema(): BglFormSchemaT<${schemaId}> {
+    return [${fieldCalls.join(',\n\t\t')}]
+}`
+		.replaceAll(`value === !0`, 'value === true')
+		.replaceAll(`value === !1`, 'value === false')
+		.replaceAll(`attrs: {}`, '')
+		.replaceAll('{}', '')
+		.replaceAll('{  }', '')
+}
+
+function generateCodeWithJson(
+	schemaId: string,
+	formSchema: FormSchema<any>
+): string {
+	const stringifiedSchema = JSON.stringify(formSchema)
+		.replaceAll(`"step":1`, '')
+		.replaceAll(`"enableTime":false`, '')
+		.replaceAll(`"multiline":false`, '')
+		.replaceAll(`"required":false`, '')
+		.replaceAll(`"attrs":{}`, '')
+		.replaceAll(`,,`, ',')
+
+	return `import type { BglFormSchemaT } from '@bagelink/vue'
+import type { ${schemaId} } from '@/client/types'
+
+/**
+ * Generated form schema for ${schemaId}
+ */
+export function generate${schemaId}FormSchema(): BglFormSchemaT<${schemaId}> {
+    return ${stringifiedSchema}
+}
+`
+}
+
+function generateCode(
+	schemaId: string,
+	formSchema: FormSchema<any>,
+	config: GeneratorConfig
+): string {
+	return config.useUtilityFunctions
+		? generateCodeWithUtilities(schemaId, formSchema, config)
+		: generateCodeWithJson(schemaId, formSchema)
+}
+
+// =============================================================================
+// FILE OPERATIONS
+// =============================================================================
+
+async function writeGeneratedCode(
+	outputFile: string,
+	content: string
+): Promise<void> {
+	const outputDir = path.dirname(outputFile)
+	if (!existsSync(outputDir)) {
+		mkdirSync(outputDir, { recursive: true })
+	}
+
+	const fullOutputPath = path.resolve(cwd(), outputFile)
+	await formatAndWriteCode(fullOutputPath, content)
+	await runEsLintOnDir(outputDir)
+
+	console.log(`📁 Output file location: ${fullOutputPath}`)
+}
+
+// =============================================================================
+// MAIN EXECUTION
+// =============================================================================
+
+async function main(): Promise<void> {
+	try {
+		console.log('⚙️  Parsing configuration...')
+		const config = parseConfiguration()
+
+		console.log(`🌐 Fetching OpenAPI schema from ${config.url}...`)
+		const openApiSchema = await fetchOpenApiSchema(config.url)
+
+		if (!openApiSchema.components?.schemas) {
+			throw new Error('OpenAPI schema has no components.schemas section')
+		}
+
+		console.log(`🔍 Finding schema: ${config.genSchemaId}`)
+		const targetSchema = getSchemaById(config.genSchemaId, openApiSchema)
+		if (!targetSchema) {
+			throw new Error(
+				`Schema with ID "${config.genSchemaId}" not found or is not resolvable`
+			)
+		}
+
+		const context: SchemaContext = { openApiSchema }
+
+		console.log(`🔄 Converting schema to form fields...`)
+		let formSchema = convertSchemaToForm(targetSchema, config.genSchemaId, context)
+
+		if (config.useTableSchema) {
+			console.log('📊 Converting form schema to table schema...')
+			formSchema = convertToTableSchema(formSchema, targetSchema, openApiSchema)
+		}
+
+		console.log('🧑‍💻 Generating TypeScript code...')
+		const codeContent = generateCode(config.genSchemaId, formSchema, config)
+
+		logVerbose(`Generated code for schema "${config.genSchemaId}":\n${codeContent}`)
+
+		console.log(`💾 Writing output to ${config.output}...`)
+		await writeGeneratedCode(config.output, codeContent)
+
+		console.log('✅ Form schema generation completed successfully!')
+	} catch (error) {
+		console.error('❌ Error generating form schema:', error)
+		exit(1)
+	}
+}
+
+// Execute the main pipeline
+main().catch(console.error)