@khester/create-dynamics-app 1.1.0 → 2.1.0

package/templates/dynamics-365-starter/tools/metadata-sync/index.js

@@ -1,512 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Metadata Sync Tool for Dynamics 365
- * Pulls entity metadata from D365 environments and generates TypeScript interfaces
- */
-
-const { program } = require('commander');
-const fs = require('fs-extra');
-const path = require('path');
-const chalk = require('chalk');
-
-program
-  .name('metadata-sync')
-  .description(
-    'Sync entity metadata from Dynamics 365 and generate TypeScript interfaces'
-  )
-  .version('1.0.0');
-
-program
-  .command('pull')
-  .description('Pull entity metadata from Dynamics 365')
-  .requiredOption('-e, --environment <env>', 'Environment (dev, test, prod)')
-  .option(
-    '-t, --entities <entities>',
-    'Comma-separated list of entities to sync'
-  )
-  .option('--all', 'Sync all custom entities')
-  .option(
-    '--output <path>',
-    'Output directory for metadata files',
-    'src/metadata'
-  )
-  .action(pullMetadata);
-
-program
-  .command('generate')
-  .description('Generate TypeScript interfaces from metadata')
-  .option('-i, --input <path>', 'Input metadata directory', 'src/metadata')
-  .option(
-    '-o, --output <path>',
-    'Output directory for TypeScript files',
-    'src/types/generated'
-  )
-  .option('--entity <entity>', 'Generate for specific entity only')
-  .action(generateTypes);
-
-program
-  .command('validate')
-  .description('Validate generated code against D365 schema')
-  .option('-e, --environment <env>', 'Environment to validate against')
-  .option('--fix', 'Automatically fix validation issues')
-  .action(validateSchema);
-
-program
-  .command('sync')
-  .description('Pull metadata and generate types in one command')
-  .requiredOption('-e, --environment <env>', 'Environment to sync from')
-  .option(
-    '-t, --entities <entities>',
-    'Comma-separated list of entities to sync'
-  )
-  .option('--all', 'Sync all custom entities')
-  .action(syncAll);
-
-async function pullMetadata(options) {
-  console.log(
-    chalk.cyan(
-      `\n🔄 Pulling metadata from ${options.environment} environment...\n`
-    )
-  );
-
-  try {
-    const config = await loadEnvironmentConfig(options.environment);
-    const entities = await getEntitiesToSync(options);
-
-    console.log(chalk.blue(`📋 Syncing ${entities.length} entities...`));
-
-    for (const entity of entities) {
-      await pullEntityMetadata(entity, config, options.output);
-    }
-
-    console.log(chalk.green('\n✅ Metadata sync completed successfully!'));
-    console.log(chalk.cyan('\n📝 Next steps:'));
-    console.log(
-      '   npm run metadata:generate  # Generate TypeScript interfaces'
-    );
-    console.log('   npm run metadata:validate # Validate against schema');
-  } catch (error) {
-    console.error(chalk.red('❌ Error pulling metadata:'), error.message);
-    process.exit(1);
-  }
-}
-
-async function generateTypes(options) {
-  console.log(chalk.cyan('\n🔧 Generating TypeScript interfaces...\n'));
-
-  try {
-    const metadataDir = options.input;
-    const outputDir = options.output;
-
-    await fs.ensureDir(outputDir);
-
-    if (options.entity) {
-      await generateEntityTypes(options.entity, metadataDir, outputDir);
-    } else {
-      const metadataFiles = await fs.readdir(metadataDir);
-      const entityFiles = metadataFiles.filter((file) =>
-        file.endsWith('.metadata.json')
-      );
-
-      for (const file of entityFiles) {
-        const entityName = file.replace('.metadata.json', '');
-        await generateEntityTypes(entityName, metadataDir, outputDir);
-      }
-
-      // Generate index file
-      await generateIndexFile(
-        entityFiles.map((f) => f.replace('.metadata.json', '')),
-        outputDir
-      );
-    }
-
-    console.log(
-      chalk.green('\n✅ TypeScript interfaces generated successfully!')
-    );
-  } catch (error) {
-    console.error(chalk.red('❌ Error generating types:'), error.message);
-    process.exit(1);
-  }
-}
-
-async function validateSchema(options) {
-  console.log(
-    chalk.cyan(`\n🔍 Validating schema against ${options.environment}...\n`)
-  );
-
-  try {
-    const config = await loadEnvironmentConfig(options.environment);
-    const validationResults = await runSchemaValidation(config);
-
-    if (validationResults.isValid) {
-      console.log(chalk.green('✅ Schema validation passed!'));
-    } else {
-      console.log(chalk.yellow('⚠️  Schema validation issues found:'));
-      validationResults.issues.forEach((issue) => {
-        console.log(chalk.yellow(`   • ${issue}`));
-      });
-
-      if (options.fix) {
-        console.log(chalk.cyan('\n🔧 Attempting to fix issues...'));
-        await fixValidationIssues(validationResults.issues);
-        console.log(chalk.green('✅ Issues fixed automatically'));
-      }
-    }
-  } catch (error) {
-    console.error(chalk.red('❌ Error validating schema:'), error.message);
-    process.exit(1);
-  }
-}
-
-async function syncAll(options) {
-  console.log(chalk.cyan('\n🚀 Starting full metadata sync...\n'));
-
-  // Pull metadata
-  await pullMetadata(options);
-
-  // Generate types
-  await generateTypes({ input: 'src/metadata', output: 'src/types/generated' });
-
-  // Validate
-  await validateSchema({ environment: options.environment });
-
-  console.log(chalk.green('\n🎉 Complete metadata sync finished!'));
-}
-
-async function loadEnvironmentConfig(environment) {
-  const configPath = path.join(
-    process.cwd(),
-    'config',
-    'environments',
-    `${environment}.json`
-  );
-
-  if (!(await fs.pathExists(configPath))) {
-    throw new Error(`Environment configuration not found: ${configPath}`);
-  }
-
-  return await fs.readJson(configPath);
-}
-
-async function getEntitiesToSync(options) {
-  if (options.all) {
-    // Get all custom entities from D365
-    return await getAllCustomEntities(options.environment);
-  } else if (options.entities) {
-    return options.entities.split(',').map((e) => e.trim());
-  } else {
-    // Default to common entities
-    return ['account', 'contact', 'opportunity', 'quote', 'invoice'];
-  }
-}
-
-async function pullEntityMetadata(entityName, config, outputDir) {
-  console.log(chalk.blue(`   📊 Pulling metadata for ${entityName}...`));
-
-  try {
-    // Simulate D365 Web API call to get entity metadata
-    const metadata = await fetchEntityMetadata(entityName, config);
-
-    // Save metadata to file
-    const metadataPath = path.join(outputDir, `${entityName}.metadata.json`);
-    await fs.ensureDir(outputDir);
-    await fs.writeJson(metadataPath, metadata, { spaces: 2 });
-
-    console.log(chalk.green(`     ✓ Saved ${entityName} metadata`));
-  } catch (error) {
-    console.log(
-      chalk.red(`     ✗ Failed to pull ${entityName}: ${error.message}`)
-    );
-  }
-}
-
-async function fetchEntityMetadata(entityName, config) {
-  // Mock implementation - in real usage, this would make actual D365 Web API calls
-  const mockMetadata = {
-    LogicalName: entityName,
-    SchemaName: entityName.charAt(0).toUpperCase() + entityName.slice(1),
-    DisplayName: entityName.charAt(0).toUpperCase() + entityName.slice(1),
-    PrimaryIdAttribute: `${entityName}id`,
-    PrimaryNameAttribute: 'name',
-    CollectionSchemaName: `${entityName}s`,
-    EntitySetName: `${entityName}s`,
-    IsCustomEntity: !['account', 'contact', 'opportunity'].includes(entityName),
-    Attributes: [
-      {
-        LogicalName: `${entityName}id`,
-        SchemaName: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)}Id`,
-        DisplayName: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} ID`,
-        AttributeType: 'Uniqueidentifier',
-        IsPrimaryId: true,
-        RequiredLevel: 'SystemRequired',
-        IsValidForCreate: false,
-        IsValidForUpdate: false,
-      },
-      {
-        LogicalName: 'name',
-        SchemaName: 'Name',
-        DisplayName: 'Name',
-        AttributeType: 'String',
-        MaxLength: 160,
-        RequiredLevel: 'ApplicationRequired',
-        IsValidForCreate: true,
-        IsValidForUpdate: true,
-      },
-      {
-        LogicalName: 'createdon',
-        SchemaName: 'CreatedOn',
-        DisplayName: 'Created On',
-        AttributeType: 'DateTime',
-        RequiredLevel: 'None',
-        IsValidForCreate: false,
-        IsValidForUpdate: false,
-      },
-      {
-        LogicalName: 'modifiedon',
-        SchemaName: 'ModifiedOn',
-        DisplayName: 'Modified On',
-        AttributeType: 'DateTime',
-        RequiredLevel: 'None',
-        IsValidForCreate: false,
-        IsValidForUpdate: false,
-      },
-    ],
-    Relationships: [],
-    OptionSets: [],
-    Keys: [],
-    LastModified: new Date().toISOString(),
-  };
-
-  // Add entity-specific attributes
-  if (entityName === 'account') {
-    mockMetadata.Attributes.push(
-      {
-        LogicalName: 'revenue',
-        SchemaName: 'Revenue',
-        DisplayName: 'Annual Revenue',
-        AttributeType: 'Money',
-        RequiredLevel: 'None',
-        IsValidForCreate: true,
-        IsValidForUpdate: true,
-      },
-      {
-        LogicalName: 'industrycode',
-        SchemaName: 'IndustryCode',
-        DisplayName: 'Industry',
-        AttributeType: 'Picklist',
-        RequiredLevel: 'None',
-        IsValidForCreate: true,
-        IsValidForUpdate: true,
-        OptionSet: 'account_industrycode',
-      }
-    );
-  }
-
-  return mockMetadata;
-}
-
-async function generateEntityTypes(entityName, metadataDir, outputDir) {
-  console.log(chalk.blue(`   🔧 Generating types for ${entityName}...`));
-
-  const metadataPath = path.join(metadataDir, `${entityName}.metadata.json`);
-
-  if (!(await fs.pathExists(metadataPath))) {
-    console.log(
-      chalk.yellow(
-        `     ⚠ Metadata file not found: ${entityName}.metadata.json`
-      )
-    );
-    return;
-  }
-
-  const metadata = await fs.readJson(metadataPath);
-
-  // Generate interface
-  const interfaceContent = generateInterfaceContent(metadata);
-  const interfacePath = path.join(outputDir, `${entityName}.types.ts`);
-  await fs.writeFile(interfacePath, interfaceContent);
-
-  // Generate constants
-  const constantsContent = generateConstantsContent(metadata);
-  const constantsPath = path.join(outputDir, `${entityName}.constants.ts`);
-  await fs.writeFile(constantsPath, constantsContent);
-
-  console.log(
-    chalk.green(`     ✓ Generated ${entityName} types and constants`)
-  );
-}
-
-function generateInterfaceContent(metadata) {
-  const interfaceName = `I${metadata.SchemaName}`;
-  const attributes = metadata.Attributes || [];
-
-  let content = `// Auto-generated interface for ${metadata.DisplayName} entity
-// Generated on: ${new Date().toISOString()}
-// Source: ${metadata.LogicalName} metadata
-
-export interface ${interfaceName} {
-`;
-
-  attributes.forEach((attr) => {
-    const tsType = mapAttributeTypeToTypeScript(attr);
-    const optional =
-      attr.RequiredLevel !== 'ApplicationRequired' &&
-      attr.RequiredLevel !== 'SystemRequired';
-    const optionalMarker = optional ? '?' : '';
-
-    content += `  /** ${attr.DisplayName} - Type: ${attr.AttributeType}${attr.MaxLength ? `, MaxLength: ${attr.MaxLength}` : ''} */\n`;
-    content += `  ${attr.LogicalName}${optionalMarker}: ${tsType};\n\n`;
-  });
-
-  content += `}
-
-export interface ${interfaceName}Create extends Omit<${interfaceName}, '${metadata.PrimaryIdAttribute}' | 'createdon' | 'modifiedon'> {}
-
-export interface ${interfaceName}Update extends Partial<Omit<${interfaceName}, '${metadata.PrimaryIdAttribute}' | 'createdon' | 'modifiedon'>> {}
-`;
-
-  return content;
-}
-
-function generateConstantsContent(metadata) {
-  const className = `${metadata.SchemaName}Constants`;
-  const attributes = metadata.Attributes || [];
-
-  let content = `// Auto-generated constants for ${metadata.DisplayName} entity
-// Generated on: ${new Date().toISOString()}
-// Source: ${metadata.LogicalName} metadata
-
-export class ${className} {
-  // Entity metadata
-  public static readonly LogicalName = '${metadata.LogicalName}';
-  public static readonly SchemaName = '${metadata.SchemaName}';
-  public static readonly CollectionName = '${metadata.EntitySetName}';
-  public static readonly DisplayName = '${metadata.DisplayName}';
-  public static readonly PrimaryIdAttribute = '${metadata.PrimaryIdAttribute}';
-  public static readonly PrimaryNameAttribute = '${metadata.PrimaryNameAttribute}';
-
-  // Attribute names
-`;
-
-  attributes.forEach((attr) => {
-    const constantName = attr.SchemaName;
-    content += `  /** Type: ${attr.AttributeType}, RequiredLevel: ${attr.RequiredLevel}${attr.MaxLength ? `, MaxLength: ${attr.MaxLength}` : ''} */\n`;
-    content += `  public static readonly ${constantName} = '${attr.LogicalName}';\n\n`;
-  });
-
-  // Add option sets if any
-  const optionSets = attributes.filter(
-    (attr) => attr.AttributeType === 'Picklist'
-  );
-  if (optionSets.length > 0) {
-    content += `  // Option Sets\n`;
-    optionSets.forEach((attr) => {
-      content += `  public static readonly ${attr.SchemaName}Options = {\n`;
-      content += `    // TODO: Add actual option values from metadata\n`;
-      content += `  };\n\n`;
-    });
-  }
-
-  // Add display names
-  content += `  // Display names for UI
-  public static readonly FieldDisplayNames = {\n`;
-  attributes.forEach((attr) => {
-    content += `    [this.${attr.SchemaName}]: '${attr.DisplayName}',\n`;
-  });
-  content += `  };\n\n`;
-
-  // Add required fields
-  const requiredFields = attributes.filter(
-    (attr) =>
-      attr.RequiredLevel === 'ApplicationRequired' ||
-      attr.RequiredLevel === 'SystemRequired'
-  );
-  content += `  // Required fields\n`;
-  content += `  public static readonly RequiredFields = [\n`;
-  requiredFields.forEach((attr) => {
-    content += `    this.${attr.SchemaName},\n`;
-  });
-  content += `  ];\n`;
-
-  content += `}\n`;
-
-  return content;
-}
-
-function mapAttributeTypeToTypeScript(attribute) {
-  switch (attribute.AttributeType) {
-    case 'String':
-    case 'Memo':
-      return 'string';
-    case 'Integer':
-    case 'BigInt':
-    case 'Double':
-    case 'Decimal':
-    case 'Money':
-      return 'number';
-    case 'Boolean':
-      return 'boolean';
-    case 'DateTime':
-      return 'Date';
-    case 'Uniqueidentifier':
-      return 'string';
-    case 'Picklist':
-    case 'State':
-    case 'Status':
-      return 'number';
-    case 'Lookup':
-    case 'Customer':
-    case 'Owner':
-      return 'string';
-    case 'MultiSelectPicklist':
-      return 'number[]';
-    default:
-      return 'unknown';
-  }
-}
-
-async function generateIndexFile(entityNames, outputDir) {
-  let content = `// Auto-generated index file for entity types
-// Generated on: ${new Date().toISOString()}
-
-`;
-
-  entityNames.forEach((entityName) => {
-    const schemaName = entityName.charAt(0).toUpperCase() + entityName.slice(1);
-    content += `export * from './${entityName}.types';\n`;
-    content += `export * from './${entityName}.constants';\n`;
-  });
-
-  const indexPath = path.join(outputDir, 'index.ts');
-  await fs.writeFile(indexPath, content);
-}
-
-async function getAllCustomEntities(environment) {
-  // Mock implementation - would make actual D365 Web API call
-  return ['account', 'contact', 'opportunity', 'quote', 'invoice'];
-}
-
-async function runSchemaValidation(config) {
-  // Mock validation - would compare generated types with actual D365 schema
-  return {
-    isValid: true,
-    issues: [],
-  };
-}
-
-async function fixValidationIssues(issues) {
-  // Mock fix implementation
-  console.log('Fixing validation issues...');
-}
-
-if (require.main === module) {
-  program.parse();
-}
-
-module.exports = {
-  pullMetadata,
-  generateTypes,
-  validateSchema,
-  syncAll,
-};