@khester/create-dynamics-app 1.0.8 → 1.1.0

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

@@ -0,0 +1,675 @@
+/**
+ * TypeScript Type Generator for Dynamics 365 Entities
+ * Converts D365 metadata to TypeScript interfaces and constants
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+class TypeScriptGenerator {
+  constructor(options = {}) {
+    this.options = {
+      generateInterfaces: true,
+      generateConstants: true,
+      generateValidators: true,
+      generateHelpers: true,
+      strictNullChecks: true,
+      includeComments: true,
+      exportAll: true,
+      ...options,
+    };
+  }
+
+  /**
+   * Generate all TypeScript files for an entity
+   */
+  async generateEntityFiles(entityMetadata, outputDir) {
+    const entityName = entityMetadata.LogicalName;
+    const results = {};
+
+    if (this.options.generateInterfaces) {
+      const interfaceContent = this.generateInterfaceFile(entityMetadata);
+      const interfacePath = path.join(outputDir, `${entityName}.interface.ts`);
+      await fs.writeFile(interfacePath, interfaceContent);
+      results.interface = interfacePath;
+    }
+
+    if (this.options.generateConstants) {
+      const constantsContent = this.generateConstantsFile(entityMetadata);
+      const constantsPath = path.join(outputDir, `${entityName}.constants.ts`);
+      await fs.writeFile(constantsPath, constantsContent);
+      results.constants = constantsPath;
+    }
+
+    if (this.options.generateValidators) {
+      const validatorContent = this.generateValidatorFile(entityMetadata);
+      const validatorPath = path.join(outputDir, `${entityName}.validator.ts`);
+      await fs.writeFile(validatorPath, validatorContent);
+      results.validator = validatorPath;
+    }
+
+    if (this.options.generateHelpers) {
+      const helperContent = this.generateHelperFile(entityMetadata);
+      const helperPath = path.join(outputDir, `${entityName}.helpers.ts`);
+      await fs.writeFile(helperPath, helperContent);
+      results.helpers = helperPath;
+    }
+
+    return results;
+  }
+
+  /**
+   * Generate TypeScript interface file
+   */
+  generateInterfaceFile(metadata) {
+    const interfaceName = `I${metadata.SchemaName}`;
+    const attributes = metadata.Attributes || [];
+
+    let content = this.generateFileHeader(metadata, 'Interface definitions');
+
+    // Import statements
+    content += this.generateImports(metadata);
+
+    // Main interface
+    content += this.generateMainInterface(interfaceName, attributes, metadata);
+
+    // Create interface (without system fields)
+    content += this.generateCreateInterface(
+      interfaceName,
+      attributes,
+      metadata
+    );
+
+    // Update interface (partial, without system fields)
+    content += this.generateUpdateInterface(
+      interfaceName,
+      attributes,
+      metadata
+    );
+
+    // Response interface (with OData annotations)
+    content += this.generateResponseInterface(
+      interfaceName,
+      attributes,
+      metadata
+    );
+
+    // Lookup interfaces for related entities
+    content += this.generateLookupInterfaces(metadata);
+
+    return content;
+  }
+
+  /**
+   * Generate constants file
+   */
+  generateConstantsFile(metadata) {
+    const className = `${metadata.SchemaName}Constants`;
+    const attributes = metadata.Attributes || [];
+
+    let content = this.generateFileHeader(metadata, 'Constants and metadata');
+
+    // Class definition
+    content += `export class ${className} {\n`;
+
+    // Entity metadata
+    content += this.generateEntityMetadata(metadata);
+
+    // Attribute constants
+    content += this.generateAttributeConstants(attributes);
+
+    // Option set constants
+    content += this.generateOptionSetConstants(attributes);
+
+    // Relationship constants
+    content += this.generateRelationshipConstants(metadata);
+
+    // Display names
+    content += this.generateDisplayNames(attributes);
+
+    // Required fields
+    content += this.generateRequiredFields(attributes);
+
+    // Field collections
+    content += this.generateFieldCollections(attributes);
+
+    content += '}\n';
+
+    return content;
+  }
+
+  /**
+   * Generate validator file
+   */
+  generateValidatorFile(metadata) {
+    const interfaceName = `I${metadata.SchemaName}`;
+    const validatorName = `${metadata.SchemaName}Validator`;
+    const attributes = metadata.Attributes || [];
+
+    let content = this.generateFileHeader(metadata, 'Validation functions');
+
+    // Import statements
+    content += `import { ${interfaceName}, ${interfaceName}Create, ${interfaceName}Update } from './${metadata.LogicalName}.interface';\n`;
+    content += `import { ${metadata.SchemaName}Constants } from './${metadata.LogicalName}.constants';\n\n`;
+
+    // Validation result interface
+    content += this.generateValidationResultInterface();
+
+    // Main validator class
+    content += this.generateValidatorClass(
+      validatorName,
+      interfaceName,
+      attributes,
+      metadata
+    );
+
+    return content;
+  }
+
+  /**
+   * Generate helper file
+   */
+  generateHelperFile(metadata) {
+    const interfaceName = `I${metadata.SchemaName}`;
+    const helperName = `${metadata.SchemaName}Helper`;
+
+    let content = this.generateFileHeader(
+      metadata,
+      'Helper functions and utilities'
+    );
+
+    // Import statements
+    content += `import { ${interfaceName} } from './${metadata.LogicalName}.interface';\n`;
+    content += `import { ${metadata.SchemaName}Constants } from './${metadata.LogicalName}.constants';\n\n`;
+
+    // Helper class
+    content += this.generateHelperClass(helperName, interfaceName, metadata);
+
+    return content;
+  }
+
+  /**
+   * Generate file header with metadata
+   */
+  generateFileHeader(metadata, description) {
+    if (!this.options.includeComments) return '';
+
+    return `/**
+ * Auto-generated ${description} for ${metadata.DisplayName} entity
+ * 
+ * Entity: ${metadata.LogicalName} (${metadata.SchemaName})
+ * Generated: ${new Date().toISOString()}
+ * Source: ${metadata.Metadata?.SyncedFrom || 'Dynamics 365'}
+ * 
+ * @warning This file is auto-generated. Do not modify manually.
+ * Re-run the metadata sync to update this file.
+ */
+
+`;
+  }
+
+  /**
+   * Generate import statements
+   */
+  generateImports(metadata) {
+    let imports = '';
+
+    // Check if we need Date type imports
+    const hasDateFields = metadata.Attributes?.some(
+      (attr) => attr.AttributeType === 'DateTime'
+    );
+    if (hasDateFields) {
+      imports += '// Note: Date fields are represented as Date objects\n';
+    }
+
+    // Check if we need lookup type imports
+    const hasLookupFields = metadata.Attributes?.some((attr) =>
+      ['Lookup', 'Customer', 'Owner'].includes(attr.AttributeType)
+    );
+    if (hasLookupFields) {
+      imports += '// Lookup fields reference related entity IDs\n';
+    }
+
+    if (imports) {
+      imports += '\n';
+    }
+
+    return imports;
+  }
+
+  /**
+   * Generate main interface
+   */
+  generateMainInterface(interfaceName, attributes, metadata) {
+    let content = `export interface ${interfaceName} {\n`;
+
+    attributes.forEach((attr) => {
+      const tsType = this.mapAttributeToTypeScript(attr);
+      const isOptional = this.isAttributeOptional(attr);
+      const optionalMarker = isOptional ? '?' : '';
+
+      if (this.options.includeComments) {
+        content += `  /** ${attr.DisplayName}`;
+        if (attr.AttributeType) content += ` - Type: ${attr.AttributeType}`;
+        if (attr.MaxLength) content += `, MaxLength: ${attr.MaxLength}`;
+        if (attr.RequiredLevel) content += `, Required: ${attr.RequiredLevel}`;
+        content += ' */\n';
+      }
+
+      content += `  ${attr.LogicalName}${optionalMarker}: ${tsType};\n\n`;
+    });
+
+    content += '}\n\n';
+    return content;
+  }
+
+  /**
+   * Generate create interface (omits system fields)
+   */
+  generateCreateInterface(interfaceName, attributes, metadata) {
+    const systemFields = [
+      metadata.PrimaryIdAttribute,
+      'createdon',
+      'modifiedon',
+      'createdby',
+      'modifiedby',
+      'versionnumber',
+      'ownerid', // Usually set by system
+    ];
+
+    const omitFields = systemFields
+      .filter((field) => attributes.some((attr) => attr.LogicalName === field))
+      .join(' | ');
+
+    let content = `export interface ${interfaceName}Create`;
+
+    if (omitFields) {
+      content += ` extends Omit<${interfaceName}, '${omitFields.replace(' | ', "' | '")}'`;
+    } else {
+      content += ` extends ${interfaceName}`;
+    }
+
+    content += ' {}\n\n';
+    return content;
+  }
+
+  /**
+   * Generate update interface (partial)
+   */
+  generateUpdateInterface(interfaceName, attributes, metadata) {
+    const systemFields = [
+      metadata.PrimaryIdAttribute,
+      'createdon',
+      'modifiedon',
+      'createdby',
+      'modifiedby',
+      'versionnumber',
+    ];
+
+    const omitFields = systemFields
+      .filter((field) => attributes.some((attr) => attr.LogicalName === field))
+      .join(' | ');
+
+    let content = `export interface ${interfaceName}Update extends Partial<`;
+
+    if (omitFields) {
+      content += `Omit<${interfaceName}, '${omitFields.replace(' | ', "' | '")}'>`;
+    } else {
+      content += interfaceName;
+    }
+
+    content += '> {}\n\n';
+    return content;
+  }
+
+  /**
+   * Generate response interface with OData annotations
+   */
+  generateResponseInterface(interfaceName, attributes, metadata) {
+    let content = `export interface ${interfaceName}Response extends ${interfaceName} {\n`;
+    content += `  '@odata.etag'?: string;\n`;
+    content += `  '@odata.context'?: string;\n`;
+
+    // Add navigation properties
+    const relationships = [
+      ...(metadata.OneToManyRelationships || []),
+      ...(metadata.ManyToOneRelationships || []),
+    ];
+
+    relationships.forEach((rel) => {
+      if (this.options.includeComments) {
+        content += `  /** Navigation property: ${rel.SchemaName} */\n`;
+      }
+      content += `  '${rel.SchemaName}'?: any; // Navigation property\n`;
+    });
+
+    content += '}\n\n';
+    return content;
+  }
+
+  /**
+   * Generate lookup interfaces
+   */
+  generateLookupInterfaces(metadata) {
+    const lookupFields =
+      metadata.Attributes?.filter((attr) =>
+        ['Lookup', 'Customer', 'Owner'].includes(attr.AttributeType)
+      ) || [];
+
+    if (lookupFields.length === 0) return '';
+
+    let content = '// Lookup field interfaces\n';
+
+    lookupFields.forEach((field) => {
+      const interfaceName = `${metadata.SchemaName}${field.SchemaName}Lookup`;
+
+      content += `export interface ${interfaceName} {\n`;
+      content += `  ${field.LogicalName}: string; // Entity ID\n`;
+      content += `  '${field.LogicalName}@OData.Community.Display.V1.FormattedValue'?: string; // Display name\n`;
+      content += `  '${field.LogicalName}@Microsoft.Dynamics.CRM.lookuplogicalname'?: string; // Entity type\n`;
+      content += '}\n\n';
+    });
+
+    return content;
+  }
+
+  /**
+   * Generate entity metadata constants
+   */
+  generateEntityMetadata(metadata) {
+    let content = '  // Entity Metadata\n';
+    content += `  public static readonly LogicalName = '${metadata.LogicalName}';\n`;
+    content += `  public static readonly SchemaName = '${metadata.SchemaName}';\n`;
+    content += `  public static readonly EntitySetName = '${metadata.EntitySetName}';\n`;
+    content += `  public static readonly DisplayName = '${metadata.DisplayName}';\n`;
+    content += `  public static readonly PrimaryIdAttribute = '${metadata.PrimaryIdAttribute}';\n`;
+    content += `  public static readonly PrimaryNameAttribute = '${metadata.PrimaryNameAttribute}';\n`;
+    content += `  public static readonly IsCustomEntity = ${metadata.IsCustomEntity};\n\n`;
+    return content;
+  }
+
+  /**
+   * Generate attribute constants
+   */
+  generateAttributeConstants(attributes) {
+    let content = '  // Attribute Names\n';
+
+    attributes.forEach((attr) => {
+      if (this.options.includeComments) {
+        content += `  /** ${attr.DisplayName} - Type: ${attr.AttributeType}`;
+        if (attr.RequiredLevel) content += `, Required: ${attr.RequiredLevel}`;
+        if (attr.MaxLength) content += `, MaxLength: ${attr.MaxLength}`;
+        content += ' */\n';
+      }
+      content += `  public static readonly ${attr.SchemaName} = '${attr.LogicalName}';\n`;
+    });
+
+    content += '\n';
+    return content;
+  }
+
+  /**
+   * Generate option set constants
+   */
+  generateOptionSetConstants(attributes) {
+    const optionSetFields = attributes.filter((attr) =>
+      ['Picklist', 'State', 'Status', 'MultiSelectPicklist'].includes(
+        attr.AttributeType
+      )
+    );
+
+    if (optionSetFields.length === 0) return '';
+
+    let content = '  // Option Set Values\n';
+
+    optionSetFields.forEach((field) => {
+      content += `  public static readonly ${field.SchemaName}Options = {\n`;
+      content += `    // TODO: Add actual option values from metadata\n`;
+      content += `    // Sync with: npm run metadata:sync-optionsets\n`;
+      content += '  } as const;\n\n';
+    });
+
+    return content;
+  }
+
+  /**
+   * Generate relationship constants
+   */
+  generateRelationshipConstants(metadata) {
+    const relationships = [
+      ...(metadata.OneToManyRelationships || []),
+      ...(metadata.ManyToOneRelationships || []),
+    ];
+
+    if (relationships.length === 0) return '';
+
+    let content = '  // Relationship Names\n';
+
+    relationships.forEach((rel) => {
+      content += `  public static readonly ${rel.SchemaName} = '${rel.SchemaName}';\n`;
+    });
+
+    content += '\n';
+    return content;
+  }
+
+  /**
+   * Generate display names object
+   */
+  generateDisplayNames(attributes) {
+    let content = '  // Display Names for UI\n';
+    content += '  public static readonly FieldDisplayNames = {\n';
+
+    attributes.forEach((attr) => {
+      content += `    [this.${attr.SchemaName}]: '${attr.DisplayName}',\n`;
+    });
+
+    content += '  } as const;\n\n';
+    return content;
+  }
+
+  /**
+   * Generate required fields array
+   */
+  generateRequiredFields(attributes) {
+    const requiredFields = attributes.filter(
+      (attr) =>
+        attr.RequiredLevel === 'ApplicationRequired' ||
+        attr.RequiredLevel === 'SystemRequired'
+    );
+
+    let content = '  // Required Fields\n';
+    content += '  public static readonly RequiredFields = [\n';
+
+    requiredFields.forEach((field) => {
+      content += `    this.${field.SchemaName},\n`;
+    });
+
+    content += '  ] as const;\n\n';
+    return content;
+  }
+
+  /**
+   * Generate field collections
+   */
+  generateFieldCollections(attributes) {
+    let content = '  // Field Collections for different operations\n';
+
+    // Create fields (exclude system fields)
+    const createFields = attributes.filter(
+      (attr) => attr.IsValidForCreate && !attr.IsPrimaryId
+    );
+    content += '  public static readonly CreateFields = [\n';
+    createFields.forEach((field) => {
+      content += `    this.${field.SchemaName},\n`;
+    });
+    content += '  ] as const;\n\n';
+
+    // Update fields
+    const updateFields = attributes.filter((attr) => attr.IsValidForUpdate);
+    content += '  public static readonly UpdateFields = [\n';
+    updateFields.forEach((field) => {
+      content += `    this.${field.SchemaName},\n`;
+    });
+    content += '  ] as const;\n\n';
+
+    return content;
+  }
+
+  /**
+   * Generate validation result interface
+   */
+  generateValidationResultInterface() {
+    return `export interface ValidationResult {
+  isValid: boolean;
+  errors: ValidationError[];
+}
+
+export interface ValidationError {
+  field: string;
+  message: string;
+  value?: any;
+}
+
+`;
+  }
+
+  /**
+   * Generate validator class
+   */
+  generateValidatorClass(validatorName, interfaceName, attributes, metadata) {
+    let content = `export class ${validatorName} {\n`;
+
+    // Validate create method
+    content += `  public static validateCreate(data: ${interfaceName}Create): ValidationResult {\n`;
+    content += '    const errors: ValidationError[] = [];\n\n';
+
+    // Required field validation
+    const requiredFields = attributes.filter(
+      (attr) =>
+        attr.RequiredLevel === 'ApplicationRequired' && attr.IsValidForCreate
+    );
+
+    requiredFields.forEach((field) => {
+      content += `    if (!data.${field.LogicalName}) {\n`;
+      content += `      errors.push({\n`;
+      content += `        field: '${field.LogicalName}',\n`;
+      content += `        message: '${field.DisplayName} is required',\n`;
+      content += `        value: data.${field.LogicalName}\n`;
+      content += '      });\n';
+      content += '    }\n\n';
+    });
+
+    // String length validation
+    const stringFields = attributes.filter(
+      (attr) => attr.AttributeType === 'String' && attr.MaxLength
+    );
+
+    stringFields.forEach((field) => {
+      content += `    if (data.${field.LogicalName} && data.${field.LogicalName}.length > ${field.MaxLength}) {\n`;
+      content += `      errors.push({\n`;
+      content += `        field: '${field.LogicalName}',\n`;
+      content += `        message: '${field.DisplayName} cannot exceed ${field.MaxLength} characters',\n`;
+      content += `        value: data.${field.LogicalName}\n`;
+      content += '      });\n';
+      content += '    }\n\n';
+    });
+
+    content += '    return { isValid: errors.length === 0, errors };\n';
+    content += '  }\n\n';
+
+    // Validate update method
+    content += `  public static validateUpdate(data: ${interfaceName}Update): ValidationResult {\n`;
+    content += '    const errors: ValidationError[] = [];\n\n';
+    content += '    // Add update-specific validation logic here\n\n';
+    content += '    return { isValid: errors.length === 0, errors };\n';
+    content += '  }\n';
+
+    content += '}\n\n';
+    return content;
+  }
+
+  /**
+   * Generate helper class
+   */
+  generateHelperClass(helperName, interfaceName, metadata) {
+    let content = `export class ${helperName} {\n`;
+
+    // Format display name method
+    content += `  public static getDisplayName(entity: ${interfaceName}): string {\n`;
+    content += `    return entity.${metadata.PrimaryNameAttribute} || 'Unnamed ${metadata.DisplayName}';\n`;
+    content += '  }\n\n';
+
+    // Convert to display object method
+    content += `  public static toDisplayObject(entity: ${interfaceName}): Record<string, string> {\n`;
+    content += '    return {\n';
+    content += `      id: entity.${metadata.PrimaryIdAttribute} || '',\n`;
+    content += `      name: this.getDisplayName(entity),\n`;
+    content += '      // Add other commonly displayed fields here\n';
+    content += '    };\n';
+    content += '  }\n\n';
+
+    // Convert to create data method
+    content += `  public static toCreateData(entity: ${interfaceName}): ${interfaceName}Create {\n`;
+    content += '    const createData: any = {};\n\n';
+    content += `    ${metadata.SchemaName}Constants.CreateFields.forEach(field => {\n`;
+    content += '      if (entity[field] !== undefined) {\n';
+    content += '        createData[field] = entity[field];\n';
+    content += '      }\n';
+    content += '    });\n\n';
+    content += '    return createData;\n';
+    content += '  }\n';
+
+    content += '}\n\n';
+    return content;
+  }
+
+  /**
+   * Map D365 attribute type to TypeScript type
+   */
+  mapAttributeToTypeScript(attribute) {
+    const typeMap = {
+      String: 'string',
+      Memo: 'string',
+      Integer: 'number',
+      BigInt: 'number',
+      Double: 'number',
+      Decimal: 'number',
+      Money: 'number',
+      Boolean: 'boolean',
+      DateTime: 'Date',
+      Uniqueidentifier: 'string',
+      Picklist: 'number',
+      State: 'number',
+      Status: 'number',
+      Lookup: 'string',
+      Customer: 'string',
+      Owner: 'string',
+      MultiSelectPicklist: 'number[]',
+      Virtual: 'any',
+      EntityName: 'string',
+      ManagedProperty: 'boolean',
+    };
+
+    const baseType = typeMap[attribute.AttributeType] || 'unknown';
+
+    // Add null union if nullable
+    if (this.options.strictNullChecks && this.isAttributeOptional(attribute)) {
+      return `${baseType} | null`;
+    }
+
+    return baseType;
+  }
+
+  /**
+   * Determine if attribute is optional
+   */
+  isAttributeOptional(attribute) {
+    return (
+      attribute.RequiredLevel !== 'ApplicationRequired' &&
+      attribute.RequiredLevel !== 'SystemRequired'
+    );
+  }
+}
+
+module.exports = { TypeScriptGenerator };

package/templates/dynamics-365-starter/tsconfig.json

@@ -1,11 +1,7 @@
 {
   "compilerOptions": {
     "target": "es5",
-    "lib": [
-      "dom",
-      "dom.iterable",
-      "es6"
-    ],
+    "lib": ["dom", "dom.iterable", "es6"],
     "allowJs": true,
     "skipLibCheck": true,
     "esModuleInterop": true,
@@ -20,7 +16,14 @@
     "noEmit": true,
     "jsx": "react-jsx"
   },
-  "include": [
-    "src"
+  "include": ["src/**/*"],
+  "exclude": [
+    "node_modules",
+    "build",
+    "dist",
+    "tools/**/*.template.ts",
+    "tools/**/templates/**/*.ts",
+    "**/templates/**/*",
+    "**/*.template.ts"
   ]
-}
+}