@khester/create-dynamics-app 1.0.8 → 1.1.0

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

@@ -0,0 +1,512 @@
+#!/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,
+};