@memberjunction/ng-dashboards 5.8.0 → 5.10.0

package/dist/Integration/services/integration-data.service.js

@@ -1,59 +1,63 @@
 import { Injectable } from '@angular/core';
-import { RunView } from '@memberjunction/core';
+import { Metadata, RunView } from '@memberjunction/core';
 import { UUIDsEqual } from '@memberjunction/global';
+import { IntegrationEngineBase } from '@memberjunction/integration-engine-base';
+import { GraphQLIntegrationClient, GraphQLActionClient } from '@memberjunction/graphql-dataprovider';
 import * as i0 from "@angular/core";
+/** Shared icon resolution map for integration names to Font Awesome icon classes */
+const INTEGRATION_ICON_MAP = [
+    { Pattern: /hubspot/i, Icon: 'fa-brands fa-hubspot' },
+    { Pattern: /salesforce/i, Icon: 'fa-brands fa-salesforce' },
+    { Pattern: /google/i, Icon: 'fa-brands fa-google' },
+    { Pattern: /microsoft|dynamics|azure/i, Icon: 'fa-brands fa-microsoft' },
+    { Pattern: /slack/i, Icon: 'fa-brands fa-slack' },
+    { Pattern: /jira|atlassian/i, Icon: 'fa-brands fa-atlassian' },
+    { Pattern: /github/i, Icon: 'fa-brands fa-github' },
+    { Pattern: /stripe/i, Icon: 'fa-brands fa-stripe' },
+    { Pattern: /shopify/i, Icon: 'fa-brands fa-shopify' },
+    { Pattern: /mailchimp/i, Icon: 'fa-brands fa-mailchimp' },
+    { Pattern: /wordpress/i, Icon: 'fa-brands fa-wordpress' },
+    { Pattern: /dropbox/i, Icon: 'fa-brands fa-dropbox' },
+    { Pattern: /csv|file|import/i, Icon: 'fa-solid fa-file-csv' },
+    { Pattern: /postgres|mysql|sql|database|db/i, Icon: 'fa-solid fa-database' },
+    { Pattern: /api|rest|graphql/i, Icon: 'fa-solid fa-code' },
+    { Pattern: /member|membership/i, Icon: 'fa-solid fa-users' },
+    { Pattern: /email|mail/i, Icon: 'fa-solid fa-envelope' },
+    { Pattern: /calendar|event/i, Icon: 'fa-solid fa-calendar' }
+];
+/** Resolve an integration name to a Font Awesome icon class */
+export function ResolveIntegrationIcon(name) {
+    const match = INTEGRATION_ICON_MAP.find(m => m.Pattern.test(name));
+    return match ? match.Icon : 'fa-solid fa-plug';
+}
 export class IntegrationDataService {
     async LoadIntegrationSummaries(provider) {
+        const engine = IntegrationEngineBase.Instance;
         const rv = this.createRunView(provider);
-        const [integrationsResult, runsResult] = await rv.RunViews([
-            {
-                EntityName: 'MJ: Company Integrations',
-                ExtraFilter: '',
-                OrderBy: 'Name',
-                Fields: ['ID', 'Name', 'IsActive', 'LastRunID',
-                    'LastRunStartedAt', 'LastRunEndedAt', 'Company', 'Integration',
-                    'DriverClassName'],
-                ResultType: 'simple'
-            },
-            {
+        // Engine provides cached metadata; only runs are dynamic and need a RunView call
+        const [, runsResult] = await Promise.all([
+            engine.Config(false),
+            rv.RunView({
                 EntityName: 'MJ: Company Integration Runs',
                 ExtraFilter: '',
                 OrderBy: 'StartedAt DESC',
                 Fields: ['ID', 'CompanyIntegrationID', 'StartedAt', 'EndedAt', 'TotalRecords',
                     'Status', 'ErrorLog', 'Integration', 'Company', 'RunByUser'],
                 ResultType: 'simple'
-            }
+            })
         ]);
-        const integrations = integrationsResult.Results;
+        const integrations = engine.CompanyIntegrations;
         const runs = runsResult.Results;
-        return integrations.map(integration => this.buildSummary(integration, runs));
+        const sourceTypes = engine.SourceTypes;
+        return integrations.map(integration => this.buildSummary(integration, runs, sourceTypes));
     }
-    async LoadEntityMaps(companyIntegrationID, provider) {
-        const rv = this.createRunView(provider);
-        const result = await rv.RunView({
-            EntityName: 'MJ: Company Integration Entity Maps',
-            ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
-            OrderBy: 'Priority, ExternalObjectName',
-            Fields: ['ID', 'CompanyIntegrationID', 'ExternalObjectName', 'ExternalObjectLabel',
-                'EntityID', 'SyncDirection', 'SyncEnabled', 'MatchStrategy',
-                'ConflictResolution', 'Priority', 'DeleteBehavior', 'Status', 'Entity'],
-            ResultType: 'simple'
-        });
-        return result.Results;
+    async LoadEntityMaps(companyIntegrationID, _provider) {
+        await IntegrationEngineBase.Instance.Config(false);
+        return IntegrationEngineBase.Instance.GetEntityMapsForCompanyIntegration(companyIntegrationID);
     }
-    async LoadFieldMaps(entityMapID, provider) {
-        const rv = this.createRunView(provider);
-        const result = await rv.RunView({
-            EntityName: 'MJ: Company Integration Field Maps',
-            ExtraFilter: `EntityMapID='${entityMapID}'`,
-            OrderBy: 'Priority, SourceFieldName',
-            Fields: ['ID', 'EntityMapID', 'SourceFieldName', 'SourceFieldLabel',
-                'DestinationFieldName', 'DestinationFieldLabel', 'Direction',
-                'TransformPipeline', 'IsKeyField', 'IsRequired', 'DefaultValue',
-                'Priority', 'Status'],
-            ResultType: 'simple'
-        });
-        return result.Results;
+    async LoadFieldMaps(entityMapID, _provider) {
+        await IntegrationEngineBase.Instance.Config(false);
+        return IntegrationEngineBase.Instance.GetFieldMapsForEntityMap(entityMapID);
     }
     async LoadRunHistory(companyIntegrationID, limit = 10, provider) {
         const rv = this.createRunView(provider);
@@ -74,36 +78,60 @@ export class IntegrationDataService {
             EntityName: 'MJ: Company Integration Run Details',
             ExtraFilter: `CompanyIntegrationRunID='${runID}'`,
             OrderBy: 'Entity',
-            Fields: ['ID', 'CompanyIntegrationRunID', 'EntityID', 'RecordsProcessed',
-                'RecordsCreated', 'RecordsUpdated', 'RecordsDeleted',
-                'RecordsErrored', 'RecordsSkipped', 'Entity'],
+            Fields: ['ID', 'CompanyIntegrationRunID', 'EntityID', 'RecordID',
+                'Action', 'IsSuccess', 'Entity'],
             ResultType: 'simple'
         });
-        return result.Results;
+        return this.aggregateRunDetails(result.Results);
     }
-    async LoadIntegrationDefinitions(provider) {
-        const rv = this.createRunView(provider);
-        const result = await rv.RunView({
-            EntityName: 'MJ: Integrations',
-            ExtraFilter: '',
-            OrderBy: 'Name',
-            Fields: ['ID', 'Name', 'Description', 'ClassName', 'ImportPath',
-                'NavigationBaseURL', 'BatchMaxRequestCount', 'BatchRequestWaitTime',
-                'CredentialTypeID'],
-            ResultType: 'simple'
-        });
-        return result.Results;
+    /** Aggregate raw per-record detail rows into per-entity summary rows */
+    aggregateRunDetails(rawRecords) {
+        const entityMap = new Map();
+        for (const rec of rawRecords) {
+            const key = rec.EntityID.toLowerCase();
+            let row = entityMap.get(key);
+            if (!row) {
+                row = {
+                    EntityID: rec.EntityID,
+                    Entity: rec.Entity,
+                    RecordsProcessed: 0,
+                    RecordsCreated: 0,
+                    RecordsUpdated: 0,
+                    RecordsDeleted: 0,
+                    RecordsErrored: 0,
+                    RecordsSkipped: 0
+                };
+                entityMap.set(key, row);
+            }
+            row.RecordsProcessed++;
+            if (!rec.IsSuccess) {
+                row.RecordsErrored++;
+            }
+            else {
+                const action = (rec.Action ?? '').toUpperCase();
+                if (action === 'INSERT' || action === 'CREATE') {
+                    row.RecordsCreated++;
+                }
+                else if (action === 'UPDATE') {
+                    row.RecordsUpdated++;
+                }
+                else if (action === 'DELETE') {
+                    row.RecordsDeleted++;
+                }
+                else if (action === 'SKIP' || action === 'SKIPPED') {
+                    row.RecordsSkipped++;
+                }
+            }
+        }
+        return Array.from(entityMap.values()).sort((a, b) => a.Entity.localeCompare(b.Entity));
     }
-    async LoadSourceTypes(provider) {
-        const rv = this.createRunView(provider);
-        const result = await rv.RunView({
-            EntityName: 'MJ: Integration Source Types',
-            ExtraFilter: 'Status=\'Active\'',
-            OrderBy: 'Name',
-            Fields: ['ID', 'Name', 'Description', 'DriverClass', 'IconClass', 'Status'],
-            ResultType: 'simple'
-        });
-        return result.Results;
+    async LoadIntegrationDefinitions(_provider) {
+        await IntegrationEngineBase.Instance.Config(false);
+        return IntegrationEngineBase.Instance.Integrations;
+    }
+    async LoadSourceTypes(_provider) {
+        await IntegrationEngineBase.Instance.Config(false);
+        return IntegrationEngineBase.Instance.SourceTypes.filter(st => st.Status === 'Active');
     }
     async LoadRecentRuns(limit = 20, provider) {
         const rv = this.createRunView(provider);
@@ -171,10 +199,293 @@ export class IntegrationDataService {
     ComputeRelativeTime(dateStr) {
         return this.computeRelativeTime(dateStr);
     }
+    // --- Entity Map CRUD ---
+    async CreateEntityMap(params) {
+        const md = new Metadata();
+        const em = await md.GetEntityObject('MJ: Company Integration Entity Maps');
+        em.NewRecord();
+        em.CompanyIntegrationID = params.CompanyIntegrationID;
+        em.ExternalObjectName = params.ExternalObjectName;
+        if (params.ExternalObjectLabel)
+            em.ExternalObjectLabel = params.ExternalObjectLabel;
+        em.EntityID = params.EntityID;
+        em.SyncDirection = params.SyncDirection ?? 'Pull';
+        em.ConflictResolution = params.ConflictResolution ?? 'SourceWins';
+        em.Priority = params.Priority ?? 0;
+        em.DeleteBehavior = params.DeleteBehavior ?? 'SoftDelete';
+        em.Status = 'Active';
+        em.SyncEnabled = true;
+        const saved = await em.Save();
+        if (!saved) {
+            console.error('[IntegrationDataService] Failed to create entity map:', em.LatestResult?.CompleteMessage);
+            return null;
+        }
+        return em;
+    }
+    async DeleteEntityMap(entityMapID) {
+        const md = new Metadata();
+        const em = await md.GetEntityObject('MJ: Company Integration Entity Maps');
+        await em.Load(entityMapID);
+        return em.Delete();
+    }
+    async ToggleEntityMapEnabled(entityMapID, enabled) {
+        const md = new Metadata();
+        const em = await md.GetEntityObject('MJ: Company Integration Entity Maps');
+        await em.Load(entityMapID);
+        em.SyncEnabled = enabled;
+        return em.Save();
+    }
+    // --- Field Map CRUD ---
+    async CreateFieldMap(params) {
+        const md = new Metadata();
+        const fm = await md.GetEntityObject('MJ: Company Integration Field Maps');
+        fm.NewRecord();
+        fm.EntityMapID = params.EntityMapID;
+        fm.SourceFieldName = params.SourceFieldName;
+        if (params.SourceFieldLabel)
+            fm.SourceFieldLabel = params.SourceFieldLabel;
+        fm.DestinationFieldName = params.DestinationFieldName;
+        if (params.DestinationFieldLabel)
+            fm.DestinationFieldLabel = params.DestinationFieldLabel;
+        fm.IsKeyField = params.IsKeyField ?? false;
+        fm.IsRequired = params.IsRequired ?? false;
+        fm.Direction = params.Direction ?? 'SourceToDest';
+        if (params.TransformPipeline !== undefined)
+            fm.TransformPipeline = params.TransformPipeline;
+        fm.Status = 'Active';
+        fm.Priority = params.Priority ?? 0;
+        const saved = await fm.Save();
+        if (!saved) {
+            console.error('[IntegrationDataService] Failed to create field map:', fm.LatestResult?.CompleteMessage);
+            return null;
+        }
+        return fm;
+    }
+    async DeleteFieldMap(fieldMapID) {
+        const md = new Metadata();
+        const fm = await md.GetEntityObject('MJ: Company Integration Field Maps');
+        await fm.Load(fieldMapID);
+        return fm.Delete();
+    }
+    async UpdateFieldMap(fieldMapID, updates) {
+        const md = new Metadata();
+        const fm = await md.GetEntityObject('MJ: Company Integration Field Maps');
+        await fm.Load(fieldMapID);
+        if (updates.SourceFieldName !== undefined)
+            fm.SourceFieldName = updates.SourceFieldName;
+        if (updates.DestinationFieldName !== undefined)
+            fm.DestinationFieldName = updates.DestinationFieldName;
+        if (updates.IsKeyField !== undefined)
+            fm.IsKeyField = updates.IsKeyField;
+        if (updates.IsRequired !== undefined)
+            fm.IsRequired = updates.IsRequired;
+        if (updates.Direction !== undefined)
+            fm.Direction = updates.Direction;
+        if (updates.Status !== undefined)
+            fm.Status = updates.Status;
+        if (updates.TransformPipeline !== undefined)
+            fm.TransformPipeline = updates.TransformPipeline;
+        return fm.Save();
+    }
+    /** Load available MJ entities for mapping target selection */
+    async LoadMJEntities(_provider) {
+        const md = new Metadata();
+        return md.Entities
+            .map(e => ({ ID: e.ID, Name: e.Name }))
+            .sort((a, b) => a.Name.localeCompare(b.Name));
+    }
+    /** Load entity fields for a given entity (for field mapping destination picker) */
+    async LoadEntityFields(entityID, _provider) {
+        const md = new Metadata();
+        const entity = md.Entities.find(e => UUIDsEqual(e.ID, entityID));
+        if (!entity)
+            return [];
+        return entity.Fields
+            .sort((a, b) => a.Sequence - b.Sequence)
+            .map(f => ({ ID: f.ID, Name: f.Name, Type: f.Type, IsRequired: !f.AllowsNull }));
+    }
+    // --- Discovery (via GraphQL) ---
+    /** Discover external objects available for a company integration */
+    async DiscoverObjects(companyIntegrationID) {
+        const client = this.getIntegrationClient();
+        return client.DiscoverObjects(companyIntegrationID);
+    }
+    /** Discover fields on a specific external object */
+    async DiscoverFields(companyIntegrationID, objectName) {
+        const client = this.getIntegrationClient();
+        return client.DiscoverFields(companyIntegrationID, objectName);
+    }
+    /** Generate DDL preview for creating tables from discovered objects */
+    async SchemaPreview(companyIntegrationID, objects, platform = 'sqlserver') {
+        const client = this.getIntegrationClient();
+        return client.SchemaPreview(companyIntegrationID, objects, platform);
+    }
+    /** Get the connector's default configuration for quick setup */
+    async GetDefaultConfig(companyIntegrationID) {
+        const client = this.getIntegrationClient();
+        return client.GetDefaultConfig(companyIntegrationID);
+    }
+    /** Test connection to the external system */
+    async TestConnection(companyIntegrationID) {
+        const client = this.getIntegrationClient();
+        return client.TestConnection(companyIntegrationID);
+    }
+    /** Preview source data from the external system via connector's FetchChanges */
+    async PreviewSourceData(companyIntegrationID, objectName, limit = 5) {
+        const client = this.getIntegrationClient();
+        const result = await client.PreviewData(companyIntegrationID, objectName, limit);
+        if (!result.Success || !result.Records) {
+            console.warn('[IntegrationDataService] PreviewSourceData failed:', result.Message);
+            return [];
+        }
+        return result.Records.map(r => {
+            try {
+                return JSON.parse(r.Data);
+            }
+            catch {
+                return { _raw: r.Data };
+            }
+        });
+    }
+    /** Preview destination data by loading a few records from the target entity */
+    async PreviewDestinationData(entityID, limit = 5, provider) {
+        const md = new Metadata();
+        const entityInfo = md.Entities.find(e => UUIDsEqual(e.ID, entityID));
+        if (!entityInfo)
+            return [];
+        // Load first N fields (skip internal __mj fields) to keep preview compact
+        const fields = entityInfo.Fields
+            .filter(f => !f.Name.startsWith('__mj'))
+            .slice(0, 8)
+            .map(f => f.Name);
+        const rv = this.createRunView(provider);
+        const result = await rv.RunView({
+            EntityName: entityInfo.Name,
+            ExtraFilter: '',
+            OrderBy: `${fields[0]} ASC`,
+            MaxRows: limit,
+            Fields: fields,
+            ResultType: 'simple'
+        });
+        return result.Results;
+    }
+    /** Get a count of records in the destination MJ entity */
+    async GetDestinationRecordCount(entityID, provider) {
+        const md = new Metadata();
+        const entityInfo = md.Entities.find(e => UUIDsEqual(e.ID, entityID));
+        if (!entityInfo)
+            return 0;
+        const rv = this.createRunView(provider);
+        const result = await rv.RunView({
+            EntityName: entityInfo.Name,
+            ExtraFilter: '',
+            Fields: [entityInfo.FirstPrimaryKey?.Name ?? 'ID'],
+            ResultType: 'simple'
+        });
+        return result.TotalRowCount ?? result.Results.length;
+    }
+    /** Get the most recent run that touched a given entity */
+    async GetLastSyncForEntity(companyIntegrationID, entityID, provider) {
+        const rv = this.createRunView(provider);
+        // Get runs for this integration, most recent first
+        const runsResult = await rv.RunView({
+            EntityName: 'MJ: Company Integration Runs',
+            ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
+            OrderBy: 'StartedAt DESC',
+            MaxRows: 5,
+            Fields: ['ID', 'CompanyIntegrationID', 'StartedAt', 'EndedAt', 'TotalRecords', 'Status'],
+            ResultType: 'simple'
+        });
+        if (runsResult.Results.length === 0)
+            return null;
+        // Check each run's details to find one that touched this entity
+        for (const run of runsResult.Results) {
+            const detailResult = await rv.RunView({
+                EntityName: 'MJ: Company Integration Run Details',
+                ExtraFilter: `CompanyIntegrationRunID='${run.ID}' AND EntityID='${entityID}'`,
+                MaxRows: 1,
+                Fields: ['EntityID'],
+                ResultType: 'simple'
+            });
+            if (detailResult.Results.length > 0) {
+                return {
+                    StartedAt: run.StartedAt,
+                    EndedAt: run.EndedAt,
+                    Status: run.Status,
+                    TotalRecords: run.TotalRecords
+                };
+            }
+        }
+        // No run touched this entity — return the most recent run anyway as context
+        const latest = runsResult.Results[0];
+        return {
+            StartedAt: latest.StartedAt,
+            EndedAt: latest.EndedAt,
+            Status: latest.Status,
+            TotalRecords: latest.TotalRecords
+        };
+    }
+    /** Run an integration sync via the "Run Integration Sync" action */
+    async RunSync(companyIntegrationID) {
+        const actionID = await this.lookupActionID('Run Integration Sync');
+        if (!actionID) {
+            return {
+                Success: false,
+                Message: 'Action "Run Integration Sync" not found. Ensure the action is registered.'
+            };
+        }
+        const provider = Metadata.Provider;
+        const actionClient = new GraphQLActionClient(provider);
+        const result = await actionClient.RunAction(actionID, [
+            { Name: 'CompanyIntegrationID', Value: companyIntegrationID, Type: 'Input' }
+        ]);
+        return { Success: result.Success, Message: result.Message ?? '' };
+    }
+    /** Load schedule data for all company integrations (includes new scheduling fields) */
+    async LoadSchedules(_provider) {
+        await IntegrationEngineBase.Instance.Config(false);
+        return IntegrationEngineBase.Instance.CompanyIntegrations;
+    }
+    /** Load sync watermarks for a specific company integration's entity maps */
+    async LoadWatermarks(companyIntegrationID, _provider) {
+        await IntegrationEngineBase.Instance.Config(false);
+        const entityMaps = IntegrationEngineBase.Instance.GetEntityMapsForCompanyIntegration(companyIntegrationID);
+        if (entityMaps.length === 0)
+            return [];
+        const mapIDSet = new Set(entityMaps.map(em => em.ID.toLowerCase()));
+        return IntegrationEngineBase.Instance.Watermarks.filter(w => mapIDSet.has(w.EntityMapID.toLowerCase()));
+    }
+    /** Load entity map count per company integration (used by Overview cards) */
+    async LoadEntityMapCounts(_provider) {
+        await IntegrationEngineBase.Instance.Config(false);
+        const counts = new Map();
+        for (const em of IntegrationEngineBase.Instance.EntityMaps) {
+            if (em.SyncEnabled) {
+                const key = em.CompanyIntegrationID.toLowerCase();
+                counts.set(key, (counts.get(key) ?? 0) + 1);
+            }
+        }
+        return counts;
+    }
+    async lookupActionID(actionName) {
+        const rv = new RunView();
+        const result = await rv.RunView({
+            EntityName: 'MJ: Actions',
+            ExtraFilter: `Name='${actionName}'`,
+            Fields: ['ID'],
+            MaxRows: 1,
+            ResultType: 'simple'
+        });
+        return result.Results.length > 0 ? result.Results[0].ID : null;
+    }
+    getIntegrationClient() {
+        const provider = Metadata.Provider;
+        return new GraphQLIntegrationClient(provider);
+    }
     createRunView(provider) {
         return new RunView(provider ?? null);
     }
-    buildSummary(integration, allRuns) {
+    buildSummary(integration, allRuns, sourceTypes) {
         const integrationRuns = allRuns.filter(r => UUIDsEqual(r.CompanyIntegrationID, integration.ID));
         const latestRun = integrationRuns.length > 0 ? integrationRuns[0] : null;
         const recentRuns = integrationRuns.slice(0, 5);
@@ -183,9 +494,10 @@ export class IntegrationDataService {
         const totalRecordsSyncedToday = this.computeRecordsSyncedToday(integrationRuns);
         const totalErrors = integrationRuns.filter(r => r.Status === 'Failed').length;
         const durationMs = this.computeDuration(latestRun);
+        const sourceType = this.resolveSourceType(integration, sourceTypes);
         return {
             Integration: integration,
-            SourceType: null,
+            SourceType: sourceType,
             LatestRun: latestRun,
             RecentRuns: recentRuns,
             StatusColor: statusColor,
@@ -195,6 +507,11 @@ export class IntegrationDataService {
             DurationMs: durationMs
         };
     }
+    resolveSourceType(integration, sourceTypes) {
+        if (!integration.SourceTypeID)
+            return null;
+        return sourceTypes.find(st => UUIDsEqual(st.ID, integration.SourceTypeID)) ?? null;
+    }
     buildActivityFeedItem(run) {
         return {
             RunID: run.ID,