create-wp-typia 0.1.0

package/templates/advanced/scripts/generate-migrations.ts.mustache

@@ -0,0 +1,267 @@
+import typia from "typia";
+import * as fs from "fs";
+import * as path from "path";
+
+/**
+ * 🚀 Auto-generate WordPress block migrations from Typia types
+ * 
+ * This script analyzes type differences and generates migration functions
+ */
+
+interface TypeField {
+	name: string;
+	type: string;
+	optional: boolean;
+	defaultValue?: any;
+	tags: string[];
+}
+
+interface VersionInfo {
+	version: string;
+	fields: TypeField[];
+	breaking: boolean;
+}
+
+async function generateMigrations() {
+	try {
+		console.log('🔄 Analyzing type versions for {{title}}...');
+		
+		// Read types file
+		const typesContent = fs.readFileSync('src/types/versions.ts', 'utf-8');
+		const versions = extractVersionInfo(typesContent);
+		
+		console.log(`📋 Found ${versions.length} versions:`, versions.map(v => v.version));
+		
+		// Generate migration functions
+		const migrations = generateMigrationFunctions(versions);
+		
+		// Update migrations file
+		const migrationsContent = generateMigrationsFile(migrations);
+		fs.writeFileSync('src/migrations/auto-generated.ts', migrationsContent);
+		
+		// Update block.json with deprecated versions
+		updateBlockJsonDeprecated(versions);
+		
+		console.log('✅ Migration generation complete!');
+		console.log('📝 Generated files:');
+		console.log('   - src/migrations/auto-generated.ts');
+		console.log('   - Updated block.json with deprecated versions');
+		
+	} catch (error) {
+		console.error('❌ Migration generation failed:', error);
+		process.exit(1);
+	}
+}
+
+function extractVersionInfo(content: string): VersionInfo[] {
+	const versions: VersionInfo[] = [];
+	
+	// Parse interface definitions
+	const interfaceRegex = /interface\s+({{titleCase}}AttributesV\d+)\s*\{([^}]+)\}/g;
+	let match;
+	
+	while ((match = interfaceRegex.exec(content)) !== null) {
+		const [, interfaceName, body] = match;
+		const versionNumber = interfaceName.match(/V(\d+)/)?.[1] || '1';
+		
+		const fields = parseFields(body);
+		const isBreaking = content.includes(`breaking: true`) && content.includes(`version: ${versionNumber}`);
+		
+		versions.push({
+			version: `${versionNumber}.0.0`,
+			fields,
+			breaking: isBreaking
+		});
+	}
+	
+	return versions.sort((a, b) => parseInt(a.version) - parseInt(b.version));
+}
+
+function parseFields(interfaceBody: string): TypeField[] {
+	const fields: TypeField[] = [];
+	const fieldRegex = /(.*?):\s*([^;]+);/g;
+	let match;
+	
+	while ((match = fieldRegex.exec(interfaceBody)) !== null) {
+		const [, fieldDecl, typeDecl] = match;
+		const fieldName = fieldDecl.trim().replace(/\?$/, '');
+		const optional = fieldDecl.includes('?');
+		
+		// Extract tags
+		const tags = extractTags(typeDecl);
+		const defaultValue = extractDefault(typeDecl);
+		const baseType = extractBaseType(typeDecl);
+		
+		fields.push({
+			name: fieldName,
+			type: baseType,
+			optional,
+			defaultValue,
+			tags
+		});
+	}
+	
+	return fields;
+}
+
+function extractTags(typeDecl: string): string[] {
+	const tagMatches = typeDecl.match(/tags\.\w+(?:<[^>]+>)?/g) || [];
+	return tagMatches;
+}
+
+function extractDefault(typeDecl: string): any {
+	const defaultMatch = typeDecl.match(/tags\.Default<([^>]+)>/);
+	if (!defaultMatch) return undefined;
+	
+	const value = defaultMatch[1].trim();
+	if (value === 'true') return true;
+	if (value === 'false') return false;
+	if (value.match(/^\d+$/)) return parseInt(value);
+	if (value.startsWith('"') && value.endsWith('"')) return value.slice(1, -1);
+	return value;
+}
+
+function extractBaseType(typeDecl: string): string {
+	// Remove tags and get base type
+	const cleanType = typeDecl.replace(/\s*&\s*tags\.[^&]+/g, '').trim();
+	if (cleanType.startsWith('string')) return 'string';
+	if (cleanType.startsWith('number')) return 'number';  
+	if (cleanType.startsWith('boolean')) return 'boolean';
+	if (cleanType.includes('|')) return 'union';
+	return 'unknown';
+}
+
+function generateMigrationFunctions(versions: VersionInfo[]): string[] {
+	const migrations: string[] = [];
+	
+	for (let i = 0; i < versions.length - 1; i++) {
+		const fromVersion = versions[i];
+		const toVersion = versions[i + 1];
+		
+		const migrationCode = generateSingleMigration(fromVersion, toVersion);
+		migrations.push(migrationCode);
+	}
+	
+	return migrations;
+}
+
+function generateSingleMigration(from: VersionInfo, to: VersionInfo): string {
+	const fromV = from.version.split('.')[0];
+	const toV = to.version.split('.')[0];
+	
+	let migrationBody = '';
+	
+	// Handle each field
+	for (const toField of to.fields) {
+		const fromField = from.fields.find(f => f.name === toField.name);
+		
+		if (!fromField) {
+			// New field - use default
+			if (toField.defaultValue !== undefined) {
+				migrationBody += `\t\t${toField.name}: ${JSON.stringify(toField.defaultValue)},\n`;
+			} else if (toField.optional) {
+				migrationBody += `\t\t${toField.name}: undefined,\n`;
+			} else {
+				migrationBody += `\t\t// TODO: Handle required field '${toField.name}' that doesn't exist in v${fromV}\n`;
+				migrationBody += `\t\t${toField.name}: ${getTypeDefault(toField.type)},\n`;
+			}
+		} else {
+			// Existing field - copy or transform
+			if (fromField.type === toField.type) {
+				migrationBody += `\t\t${toField.name}: v${fromV}Attrs.${toField.name}`;
+				if (toField.defaultValue !== undefined) {
+					migrationBody += ` ?? ${JSON.stringify(toField.defaultValue)}`;
+				}
+				migrationBody += ',\n';
+			} else {
+				migrationBody += `\t\t// TODO: Transform ${toField.name} from ${fromField.type} to ${toField.type}\n`;
+				migrationBody += `\t\t${toField.name}: v${fromV}Attrs.${toField.name} as any,\n`;
+			}
+		}
+	}
+	
+	return `
+// V${fromV} → V${toV} Migration (Auto-generated)
+export function migrateV${fromV}ToV${toV}(v${fromV}Attrs: {{titleCase}}AttributesV${fromV}): {{titleCase}}AttributesV${toV} {
+	console.log('🔄 Auto-migrating {{title}} from v${fromV} to v${toV}');
+	
+	const migrated: {{titleCase}}AttributesV${toV} = {
+${migrationBody.trimEnd()}
+	};
+	
+	// Validate migrated data
+	const validation = typia.validate<{{titleCase}}AttributesV${toV}>(migrated);
+	if (!validation.success) {
+		console.error('❌ V${fromV}→V${toV} migration validation failed:', validation.errors);
+		throw new Error('Auto-migration validation failed');
+	}
+	
+	console.log('✅ V${fromV}→V${toV} auto-migration successful');
+	return migrated;
+}`;
+}
+
+function getTypeDefault(type: string): string {
+	switch (type) {
+		case 'string': return '""';
+		case 'number': return '0';
+		case 'boolean': return 'false';
+		case 'union': return '""'; // Assume string union
+		default: return 'undefined';
+	}
+}
+
+function generateMigrationsFile(migrations: string[]): string {
+	return `/**
+ * 🤖 AUTO-GENERATED MIGRATIONS
+ * Generated by generate-migrations script from Typia types
+ * Do not edit manually - regenerate with: bun run generate-migrations
+ */
+
+import typia from "typia";
+import { 
+	{{titleCase}}AttributesV1, 
+	{{titleCase}}AttributesV2, 
+	{{titleCase}}AttributesV3,
+	{{titleCase}}Attributes
+} from '../types/versions';
+
+${migrations.join('\n')}
+
+/**
+ * Auto-migration registry
+ */
+export const AUTO_MIGRATIONS = {
+${migrations.map(m => {
+	const match = m.match(/migrateV(\d+)ToV(\d+)/);
+	if (match) {
+		return `\t"${match[1]}.0.0->${match[2]}.0.0": migrateV${match[1]}ToV${match[2]},`;
+	}
+	return '';
+}).filter(Boolean).join('\n')}
+} as const;
+`;
+}
+
+function updateBlockJsonDeprecated(versions: VersionInfo[]) {
+	const blockJsonPath = 'src/{{slug}}/block.json';
+	if (!fs.existsSync(blockJsonPath)) return;
+	
+	const blockJson = JSON.parse(fs.readFileSync(blockJsonPath, 'utf-8'));
+	
+	// Add deprecated versions
+	const deprecated = versions.slice(0, -1).map((version, index) => ({
+		version: version.version,
+		isEligible: true,
+		migrate: `migrateV${parseInt(version.version)}ToV${parseInt(versions[index + 1].version)}`
+	}));
+	
+	if (deprecated.length > 0) {
+		blockJson.deprecated = deprecated;
+	}
+	
+	fs.writeFileSync(blockJsonPath, JSON.stringify(blockJson, null, '\t'));
+}
+
+// Run script
+generateMigrations().catch(console.error);