@khester/create-dynamics-app 1.0.8 → 1.1.0

package/templates/dynamics-365-starter/tools/entity-generator/templates/model.template.ts

@@ -0,0 +1,250 @@
+// Replace 'SampleEntity' with your actual entity PascalCase name during template processing
+// import { BaseEntity } from './BaseEntity';
+// import { IApiService } from '../services/IApiService';
+// import { Logger } from '../components/Logging/logger';
+// import { SampleEntityConstants } from '../constants/sample-entity';
+
+// Template base entity class - replace with actual BaseEntity during generation
+abstract class BaseEntity {
+  id?: string;
+  [key: string]: any;
+}
+
+// Template API service interface - replace with actual IApiService during generation
+interface IApiService {
+  createRecord(entityName: string, data: any): Promise<any>;
+  updateRecord(entityName: string, id: string, data: any): Promise<any>;
+  deleteRecord(entityName: string, id: string): Promise<void>;
+  retrieveMultipleRecords(entityName: string, fetchXml: string): Promise<{ entities: any[] }>;
+}
+
+// Template Logger - replace with actual Logger during generation
+const Logger = {
+  log: (message: string, source?: string) => console.log(message, source),
+  warn: (message: string, source?: string) => console.warn(message, source),
+  error: (message: string, source?: string, error?: any) => console.error(message, source, error)
+};
+
+// Template constants - replace with actual constants during generation
+const SampleEntityConstants = {
+  EntityLogicalName: 'sample_entity',
+  PrimaryIdAttribute: 'sample_entityid',
+  PrimaryNameAttribute: 'name',
+  FieldDisplayNames: {
+    sample_entityid: 'ID',
+    name: 'Name'
+  }
+};
+
+export interface ISampleEntity {
+  sample_entityid: string;
+  name: string;
+  createdOn?: Date;
+  modifiedOn?: Date;
+}
+
+/**
+ * Sample Entity entity model with CRUD operations
+ * Generated by Entity Generator
+ */
+export class SampleEntity extends BaseEntity implements ISampleEntity {
+  public sample_entityid: string = '';
+  public name: string = '';
+  public createdOn?: Date;
+  public modifiedOn?: Date;
+
+  constructor(data?: Partial<ISampleEntity>) {
+    super();
+    if (data) {
+      Object.assign(this, data);
+    }
+  }
+
+  /**
+   * Create a new Sample Entity record
+   */
+  public static async create(apiService: IApiService, sampleEntity: SampleEntity): Promise<SampleEntity> {
+    try {
+      Logger.log(`Creating new Sample Entity: ${sampleEntity.name}`);
+      
+      const data = sampleEntity.toCreateData();
+      const result = await apiService.createRecord(SampleEntityConstants.EntityLogicalName, data);
+      
+      const createdSampleEntity = new SampleEntity({
+        ...sampleEntity,
+        sample_entityid: result.id || result.sample_entityid
+      });
+      
+      Logger.log(`Sample Entity created successfully with ID: ${createdSampleEntity.sample_entityid}`);
+      return createdSampleEntity;
+    } catch (error) {
+      Logger.error(`Error creating Sample Entity:`, error);
+      throw new Error(`Failed to create Sample Entity: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Retrieve Sample Entity by ID
+   */
+  public static async retrieveById(apiService: IApiService, id: string): Promise<SampleEntity | null> {
+    try {
+      Logger.log(`Retrieving Sample Entity with ID: ${id}`);
+      
+      const fetchXml = `
+        <fetch top="1">
+          <entity name="${SampleEntityConstants.EntityLogicalName}">
+            <attribute name="sample_entityid" />
+            <attribute name="name" />
+            <attribute name="createdon" />
+            <attribute name="modifiedon" />
+            <filter>
+              <condition attribute="sample_entityid" operator="eq" value="${id}" />
+            </filter>
+          </entity>
+        </fetch>`;
+      
+      const result = await apiService.retrieveMultipleRecords(SampleEntityConstants.EntityLogicalName, fetchXml);
+      
+      if (result.entities && result.entities.length > 0) {
+        const entity = result.entities[0];
+        return new SampleEntity({
+          sample_entityid: entity.sample_entityid,
+          name: entity.name,
+          createdOn: entity.createdon ? new Date(entity.createdon) : undefined,
+          modifiedOn: entity.modifiedon ? new Date(entity.modifiedon) : undefined
+        });
+      }
+      
+      Logger.warn(`Sample Entity not found with ID: ${id}`);
+      return null;
+    } catch (error) {
+      Logger.error(`Error retrieving Sample Entity by ID:`, error);
+      throw new Error(`Failed to retrieve Sample Entity: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Retrieve multiple sampleEntities with optional filter
+   */
+  public static async retrieveByFilter(apiService: IApiService, filter?: string, top?: number): Promise<SampleEntity[]> {
+    try {
+      Logger.log(`Retrieving sampleEntities with filter: ${filter || 'none'}`);
+      
+      const topClause = top ? `top="${top}"` : '';
+      const filterClause = filter ? `<filter>${filter}</filter>` : '';
+      
+      const fetchXml = `
+        <fetch ${topClause}>
+          <entity name="${SampleEntityConstants.EntityLogicalName}">
+            <attribute name="sample_entityid" />
+            <attribute name="name" />
+            <attribute name="createdon" />
+            <attribute name="modifiedon" />
+            <order attribute="name" />
+            ${filterClause}
+          </entity>
+        </fetch>`;
+      
+      const result = await apiService.retrieveMultipleRecords(SampleEntityConstants.EntityLogicalName, fetchXml);
+      
+      const sampleEntities = (result.entities || []).map(entity => new SampleEntity({
+        sample_entityid: entity.sample_entityid,
+        name: entity.name,
+        createdOn: entity.createdon ? new Date(entity.createdon) : undefined,
+        modifiedOn: entity.modifiedon ? new Date(entity.modifiedon) : undefined
+      }));
+      
+      Logger.log(`Retrieved ${sampleEntities.length} sampleEntities`);
+      return sampleEntities;
+    } catch (error) {
+      Logger.error(`Error retrieving sampleEntities:`, error);
+      throw new Error(`Failed to retrieve sampleEntities: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Update the Sample Entity record
+   */
+  public async update(apiService: IApiService): Promise<SampleEntity> {
+    try {
+      if (!this.sample_entityid) {
+        throw new Error('Cannot update Sample Entity without ID');
+      }
+      
+      Logger.log(`Updating Sample Entity: ${this.name}`);
+      
+      const data = this.toUpdateData();
+      await apiService.updateRecord(
+        SampleEntityConstants.EntityLogicalName,
+        this.sample_entityid,
+        data
+      );
+      
+      Logger.log(`Sample Entity updated successfully`);
+      return this;
+    } catch (error) {
+      Logger.error(`Error updating Sample Entity:`, error);
+      throw new Error(`Failed to update Sample Entity: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Delete the Sample Entity record
+   */
+  public async delete(apiService: IApiService): Promise<void> {
+    try {
+      if (!this.sample_entityid) {
+        throw new Error('Cannot delete Sample Entity without ID');
+      }
+      
+      Logger.log(`Deleting Sample Entity: ${this.name}`);
+      
+      await apiService.deleteRecord(
+        SampleEntityConstants.EntityLogicalName,
+        this.sample_entityid
+      );
+      
+      Logger.log(`Sample Entity deleted successfully`);
+    } catch (error) {
+      Logger.error(`Error deleting Sample Entity:`, error);
+      throw new Error(`Failed to delete Sample Entity: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Validate the Sample Entity data
+   */
+  public validate(): { isValid: boolean; errors: string[] } {
+    const errors: string[] = [];
+    
+    // Add your validation rules here
+    if (!this.name?.trim()) {
+      errors.push(`${name} is required`);
+    }
+    
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Convert to data for create operation
+   */
+  private toCreateData(): any {
+    return {
+      name: this.name
+      // Add other fields as needed
+    };
+  }
+
+  /**
+   * Convert to data for update operation
+   */
+  private toUpdateData(): any {
+    return {
+      name: this.name
+      // Add other fields as needed
+    };
+  }
+}

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

@@ -0,0 +1,410 @@
+/**
+ * Dynamics 365 Web API Client for Metadata Operations
+ * Handles authentication and API calls to retrieve entity metadata
+ */
+
+const https = require('https');
+const { AuthenticationProvider } = require('@azure/msal-node');
+
+class D365MetadataClient {
+  constructor(config) {
+    this.config = config;
+    this.accessToken = null;
+    this.tokenExpiry = null;
+  }
+
+  /**
+   * Authenticate with Dynamics 365 using service principal
+   */
+  async authenticate() {
+    try {
+      const authUrl = `${this.config.authentication.authority}/oauth2/v2.0/token`;
+      const authData = new URLSearchParams({
+        client_id: this.config.authentication.clientId,
+        client_secret: this.config.authentication.clientSecret,
+        scope: `${this.config.dynamics365.webApiUrl}/.default`,
+        grant_type: 'client_credentials',
+      });
+
+      const response = await this.makeHttpRequest(authUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: authData.toString(),
+      });
+
+      this.accessToken = response.access_token;
+      this.tokenExpiry = Date.now() + response.expires_in * 1000;
+
+      return true;
+    } catch (error) {
+      throw new Error(`Authentication failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Ensure we have a valid access token
+   */
+  async ensureAuthenticated() {
+    if (!this.accessToken || Date.now() >= this.tokenExpiry) {
+      await this.authenticate();
+    }
+  }
+
+  /**
+   * Get all entity definitions
+   */
+  async getAllEntities(includeSystemEntities = false) {
+    await this.ensureAuthenticated();
+
+    const filter = includeSystemEntities
+      ? ''
+      : '?$filter=IsCustomEntity eq true';
+    const url = `${this.config.dynamics365.webApiUrl}/EntityDefinitions${filter}&$select=LogicalName,SchemaName,DisplayName,IsCustomEntity`;
+
+    try {
+      const response = await this.makeApiRequest(url);
+      return response.value || [];
+    } catch (error) {
+      throw new Error(`Failed to retrieve entities: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get detailed metadata for a specific entity
+   */
+  async getEntityMetadata(entityLogicalName) {
+    await this.ensureAuthenticated();
+
+    const url =
+      `${this.config.dynamics365.webApiUrl}/EntityDefinitions(LogicalName='${entityLogicalName}')` +
+      '?$expand=Attributes($select=LogicalName,SchemaName,DisplayName,AttributeType,RequiredLevel,MaxLength,IsPrimaryId,IsValidForCreate,IsValidForUpdate),' +
+      'OneToManyRelationships($select=SchemaName,ReferencingEntity,ReferencingAttribute,ReferencedEntity,ReferencedAttribute),' +
+      'ManyToOneRelationships($select=SchemaName,ReferencingEntity,ReferencingAttribute,ReferencedEntity,ReferencedAttribute)';
+
+    try {
+      const response = await this.makeApiRequest(url);
+      return this.transformEntityMetadata(response);
+    } catch (error) {
+      throw new Error(
+        `Failed to retrieve metadata for ${entityLogicalName}: ${error.message}`
+      );
+    }
+  }
+
+  /**
+   * Get option set metadata
+   */
+  async getOptionSetMetadata(optionSetName) {
+    await this.ensureAuthenticated();
+
+    const url =
+      `${this.config.dynamics365.webApiUrl}/GlobalOptionSetDefinitions(Name='${optionSetName}')` +
+      '?$expand=Options($select=Value,Label)';
+
+    try {
+      const response = await this.makeApiRequest(url);
+      return this.transformOptionSetMetadata(response);
+    } catch (error) {
+      throw new Error(
+        `Failed to retrieve option set ${optionSetName}: ${error.message}`
+      );
+    }
+  }
+
+  /**
+   * Get all custom entities with their basic metadata
+   */
+  async getCustomEntities() {
+    await this.ensureAuthenticated();
+
+    const url =
+      `${this.config.dynamics365.webApiUrl}/EntityDefinitions` +
+      '?$filter=IsCustomEntity eq true&$select=LogicalName,SchemaName,DisplayName,PrimaryIdAttribute,PrimaryNameAttribute,EntitySetName';
+
+    try {
+      const response = await this.makeApiRequest(url);
+      return response.value || [];
+    } catch (error) {
+      throw new Error(`Failed to retrieve custom entities: ${error.message}`);
+    }
+  }
+
+  /**
+   * Validate entity exists and get basic info
+   */
+  async validateEntity(entityLogicalName) {
+    await this.ensureAuthenticated();
+
+    const url =
+      `${this.config.dynamics365.webApiUrl}/EntityDefinitions(LogicalName='${entityLogicalName}')` +
+      '?$select=LogicalName,SchemaName,DisplayName,IsCustomEntity,PrimaryIdAttribute,PrimaryNameAttribute';
+
+    try {
+      const response = await this.makeApiRequest(url);
+      return {
+        exists: true,
+        metadata: response,
+      };
+    } catch (error) {
+      if (error.status === 404) {
+        return {
+          exists: false,
+          error: `Entity '${entityLogicalName}' not found`,
+        };
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Transform D365 metadata to our standardized format
+   */
+  transformEntityMetadata(d365Metadata) {
+    return {
+      LogicalName: d365Metadata.LogicalName,
+      SchemaName: d365Metadata.SchemaName,
+      DisplayName: this.getLocalizedLabel(d365Metadata.DisplayName),
+      PrimaryIdAttribute: d365Metadata.PrimaryIdAttribute,
+      PrimaryNameAttribute: d365Metadata.PrimaryNameAttribute,
+      CollectionSchemaName: d365Metadata.CollectionSchemaName,
+      EntitySetName: d365Metadata.EntitySetName,
+      IsCustomEntity: d365Metadata.IsCustomEntity,
+      Attributes: this.transformAttributes(d365Metadata.Attributes || []),
+      OneToManyRelationships: this.transformRelationships(
+        d365Metadata.OneToManyRelationships || []
+      ),
+      ManyToOneRelationships: this.transformRelationships(
+        d365Metadata.ManyToOneRelationships || []
+      ),
+      LastModified: new Date().toISOString(),
+      Metadata: {
+        SyncedAt: new Date().toISOString(),
+        SyncedFrom: this.config.dynamics365.webApiUrl,
+        Version: '1.0',
+      },
+    };
+  }
+
+  /**
+   * Transform D365 attributes to our format
+   */
+  transformAttributes(d365Attributes) {
+    return d365Attributes.map((attr) => ({
+      LogicalName: attr.LogicalName,
+      SchemaName: attr.SchemaName,
+      DisplayName: this.getLocalizedLabel(attr.DisplayName),
+      AttributeType: this.mapAttributeType(attr.AttributeType),
+      RequiredLevel: this.mapRequiredLevel(attr.RequiredLevel),
+      MaxLength: attr.MaxLength,
+      IsPrimaryId: attr.IsPrimaryId,
+      IsValidForCreate: attr.IsValidForCreate,
+      IsValidForUpdate: attr.IsValidForUpdate,
+      IsLogical: attr.IsLogical,
+      OptionSet: attr.OptionSet?.Name,
+      Target: attr.Targets ? attr.Targets[0] : undefined, // For lookup fields
+      Precision: attr.Precision,
+      MinValue: attr.MinValue,
+      MaxValue: attr.MaxValue,
+    }));
+  }
+
+  /**
+   * Transform D365 relationships to our format
+   */
+  transformRelationships(d365Relationships) {
+    return d365Relationships.map((rel) => ({
+      SchemaName: rel.SchemaName,
+      ReferencingEntity: rel.ReferencingEntity,
+      ReferencingAttribute: rel.ReferencingAttribute,
+      ReferencedEntity: rel.ReferencedEntity,
+      ReferencedAttribute: rel.ReferencedAttribute,
+      RelationshipType: rel.RelationshipType,
+    }));
+  }
+
+  /**
+   * Transform option set metadata
+   */
+  transformOptionSetMetadata(d365OptionSet) {
+    return {
+      Name: d365OptionSet.Name,
+      DisplayName: this.getLocalizedLabel(d365OptionSet.DisplayName),
+      Description: this.getLocalizedLabel(d365OptionSet.Description),
+      Options: (d365OptionSet.Options || []).map((option) => ({
+        Value: option.Value,
+        Label: this.getLocalizedLabel(option.Label),
+        Description: this.getLocalizedLabel(option.Description),
+      })),
+    };
+  }
+
+  /**
+   * Map D365 attribute types to our standardized types
+   */
+  mapAttributeType(d365Type) {
+    const typeMap = {
+      String: 'String',
+      Memo: 'Memo',
+      Integer: 'Integer',
+      BigInt: 'BigInt',
+      Double: 'Double',
+      Decimal: 'Decimal',
+      Money: 'Money',
+      Boolean: 'Boolean',
+      DateTime: 'DateTime',
+      Uniqueidentifier: 'Uniqueidentifier',
+      Picklist: 'Picklist',
+      State: 'State',
+      Status: 'Status',
+      Lookup: 'Lookup',
+      Customer: 'Customer',
+      Owner: 'Owner',
+      MultiSelectPicklist: 'MultiSelectPicklist',
+      Virtual: 'Virtual',
+      EntityName: 'EntityName',
+      ManagedProperty: 'ManagedProperty',
+    };
+
+    return typeMap[d365Type] || d365Type;
+  }
+
+  /**
+   * Map D365 required levels to our format
+   */
+  mapRequiredLevel(d365RequiredLevel) {
+    const levelMap = {
+      ApplicationRequired: 'ApplicationRequired',
+      SystemRequired: 'SystemRequired',
+      Recommended: 'Recommended',
+      None: 'None',
+    };
+
+    return levelMap[d365RequiredLevel] || d365RequiredLevel;
+  }
+
+  /**
+   * Extract localized label (defaults to English)
+   */
+  getLocalizedLabel(labelCollection) {
+    if (!labelCollection || !labelCollection.LocalizedLabels) {
+      return '';
+    }
+
+    // Try to find English label first
+    const englishLabel = labelCollection.LocalizedLabels.find(
+      (label) => label.LanguageCode === 1033
+    );
+
+    if (englishLabel) {
+      return englishLabel.Label;
+    }
+
+    // Fall back to first available label
+    if (labelCollection.LocalizedLabels.length > 0) {
+      return labelCollection.LocalizedLabels[0].Label;
+    }
+
+    return '';
+  }
+
+  /**
+   * Make authenticated API request to D365
+   */
+  async makeApiRequest(url, options = {}) {
+    const headers = {
+      Authorization: `Bearer ${this.accessToken}`,
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      'OData-MaxVersion': '4.0',
+      'OData-Version': '4.0',
+      ...options.headers,
+    };
+
+    return this.makeHttpRequest(url, {
+      ...options,
+      headers,
+    });
+  }
+
+  /**
+   * Make HTTP request with proper error handling
+   */
+  async makeHttpRequest(url, options = {}) {
+    return new Promise((resolve, reject) => {
+      const urlObj = new URL(url);
+      const requestOptions = {
+        hostname: urlObj.hostname,
+        port: urlObj.port || 443,
+        path: urlObj.pathname + urlObj.search,
+        method: options.method || 'GET',
+        headers: options.headers || {},
+      };
+
+      const req = https.request(requestOptions, (res) => {
+        let data = '';
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+              const jsonData = data ? JSON.parse(data) : {};
+              resolve(jsonData);
+            } else {
+              const error = new Error(
+                `HTTP ${res.statusCode}: ${res.statusMessage}`
+              );
+              error.status = res.statusCode;
+              error.response = data;
+              reject(error);
+            }
+          } catch (parseError) {
+            reject(
+              new Error(`Failed to parse response: ${parseError.message}`)
+            );
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(new Error(`Request failed: ${error.message}`));
+      });
+
+      if (options.body) {
+        req.write(options.body);
+      }
+
+      req.end();
+    });
+  }
+
+  /**
+   * Test connection to D365
+   */
+  async testConnection() {
+    try {
+      await this.ensureAuthenticated();
+
+      // Make a simple request to validate connection
+      const url = `${this.config.dynamics365.webApiUrl}/WhoAmI()`;
+      const response = await this.makeApiRequest(url);
+
+      return {
+        success: true,
+        userId: response.UserId,
+        organizationId: response.OrganizationId,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  }
+}
+
+module.exports = { D365MetadataClient };