newo 3.4.0 → 3.4.2

package/dist/domain/strategies/sync/ISyncStrategy.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Generic Sync Strategy Interface
+ *
+ * All resource types (Projects, Integrations, AKB, Attributes) implement this interface.
+ * This enables the SyncEngine to handle all resources uniformly.
+ */
+import type { CustomerConfig } from '../../resources/common/types.js';
+/**
+ * Validation result for pre-sync validation
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+export interface ValidationError {
+    field: string;
+    message: string;
+    path?: string;
+}
+/**
+ * Change operation types
+ */
+export type ChangeOperation = 'created' | 'modified' | 'deleted';
+/**
+ * Generic change item representing a resource change
+ */
+export interface ChangeItem<T = unknown> {
+    item: T;
+    operation: ChangeOperation;
+    path: string;
+}
+/**
+ * Pull result containing resources and metadata
+ */
+export interface PullResult<T = unknown> {
+    items: T[];
+    count: number;
+    hashes: Record<string, string>;
+}
+/**
+ * Push result containing operation outcomes
+ */
+export interface PushResult {
+    created: number;
+    updated: number;
+    deleted: number;
+    errors: string[];
+}
+/**
+ * Generic Sync Strategy Interface
+ *
+ * TRemote - Type from the API (e.g., API response types)
+ * TLocal - Type for local storage (e.g., YAML/JSON file types)
+ */
+export interface ISyncStrategy<_TRemote = unknown, TLocal = unknown> {
+    /**
+     * Resource type identifier (e.g., 'projects', 'integrations', 'akb', 'attributes')
+     */
+    readonly resourceType: string;
+    /**
+     * Display name for logging/UI (e.g., 'Projects', 'Integrations')
+     */
+    readonly displayName: string;
+    /**
+     * Pull resources from NEWO platform to local filesystem
+     *
+     * @param customer - Customer configuration
+     * @param options - Optional pull options
+     * @returns Pull result with items and hashes
+     */
+    pull(customer: CustomerConfig, options?: PullOptions): Promise<PullResult<TLocal>>;
+    /**
+     * Push local changes to NEWO platform
+     *
+     * @param customer - Customer configuration
+     * @param changes - Changes to push (if not provided, detect changes automatically)
+     * @returns Push result with counts
+     */
+    push(customer: CustomerConfig, changes?: ChangeItem<TLocal>[]): Promise<PushResult>;
+    /**
+     * Detect what has changed locally since last sync
+     *
+     * @param customer - Customer configuration
+     * @returns Array of changed items
+     */
+    getChanges(customer: CustomerConfig): Promise<ChangeItem<TLocal>[]>;
+    /**
+     * Validate local state before push
+     *
+     * @param customer - Customer configuration
+     * @param items - Items to validate
+     * @returns Validation result
+     */
+    validate(customer: CustomerConfig, items: TLocal[]): Promise<ValidationResult>;
+    /**
+     * Get status summary for display
+     *
+     * @param customer - Customer configuration
+     * @returns Status summary
+     */
+    getStatus(customer: CustomerConfig): Promise<StatusSummary>;
+}
+/**
+ * Pull operation options
+ */
+export interface PullOptions {
+    /**
+     * Overwrite local changes without prompting
+     */
+    silentOverwrite?: boolean;
+    /**
+     * Enable verbose logging
+     */
+    verbose?: boolean;
+    /**
+     * Specific project ID to pull (for projects strategy)
+     */
+    projectId?: string | null;
+    /**
+     * Skip deletion detection and cleanup
+     */
+    skipCleanup?: boolean;
+}
+/**
+ * Status summary for a resource type
+ */
+export interface StatusSummary {
+    resourceType: string;
+    displayName: string;
+    changedCount: number;
+    changes: Array<{
+        path: string;
+        operation: ChangeOperation;
+        details?: string;
+    }>;
+}
+/**
+ * Abstract base class with common strategy functionality
+ */
+export declare abstract class BaseSyncStrategy<TRemote = unknown, TLocal = unknown> implements ISyncStrategy<TRemote, TLocal> {
+    abstract readonly resourceType: string;
+    abstract readonly displayName: string;
+    abstract pull(customer: CustomerConfig, options?: PullOptions): Promise<PullResult<TLocal>>;
+    abstract push(customer: CustomerConfig, changes?: ChangeItem<TLocal>[]): Promise<PushResult>;
+    abstract getChanges(customer: CustomerConfig): Promise<ChangeItem<TLocal>[]>;
+    abstract validate(customer: CustomerConfig, items: TLocal[]): Promise<ValidationResult>;
+    getStatus(customer: CustomerConfig): Promise<StatusSummary>;
+}
+//# sourceMappingURL=ISyncStrategy.d.ts.map

package/dist/domain/strategies/sync/ISyncStrategy.js

@@ -0,0 +1,24 @@
+/**
+ * Generic Sync Strategy Interface
+ *
+ * All resource types (Projects, Integrations, AKB, Attributes) implement this interface.
+ * This enables the SyncEngine to handle all resources uniformly.
+ */
+/**
+ * Abstract base class with common strategy functionality
+ */
+export class BaseSyncStrategy {
+    async getStatus(customer) {
+        const changes = await this.getChanges(customer);
+        return {
+            resourceType: this.resourceType,
+            displayName: this.displayName,
+            changedCount: changes.length,
+            changes: changes.map(c => ({
+                path: c.path,
+                operation: c.operation
+            }))
+        };
+    }
+}
+//# sourceMappingURL=ISyncStrategy.js.map

package/dist/domain/strategies/sync/IntegrationSyncStrategy.d.ts

@@ -0,0 +1,68 @@
+/**
+ * IntegrationSyncStrategy - Handles synchronization of Integrations, Connectors, and Webhooks
+ *
+ * This strategy implements ISyncStrategy for the Integrations resource.
+ *
+ * Key responsibilities:
+ * - Pull integrations from NEWO platform
+ * - Pull connectors for each integration
+ * - Pull webhooks (outgoing and incoming)
+ * - Push connector changes back to platform
+ * - Detect changes using stored hashes
+ */
+import type { ISyncStrategy, PullOptions, PullResult, PushResult, ChangeItem, ValidationResult, StatusSummary } from './ISyncStrategy.js';
+import type { CustomerConfig, ILogger } from '../../resources/common/types.js';
+import type { AxiosInstance } from 'axios';
+import type { Integration, IntegrationMetadata, ConnectorMetadata, OutgoingWebhook, IncomingWebhook } from '../../../types.js';
+/**
+ * Local integration data for storage
+ */
+export interface LocalIntegrationData {
+    integration: IntegrationMetadata;
+    connectors: ConnectorMetadata[];
+    outgoingWebhooks: OutgoingWebhook[];
+    incomingWebhooks: IncomingWebhook[];
+}
+/**
+ * API client factory type
+ */
+export type ApiClientFactory = (customer: CustomerConfig, verbose: boolean) => Promise<AxiosInstance>;
+/**
+ * IntegrationSyncStrategy - Handles integration synchronization
+ */
+export declare class IntegrationSyncStrategy implements ISyncStrategy<Integration, LocalIntegrationData> {
+    private apiClientFactory;
+    private logger;
+    readonly resourceType = "integrations";
+    readonly displayName = "Integrations";
+    constructor(apiClientFactory: ApiClientFactory, logger: ILogger);
+    /**
+     * Pull all integrations from NEWO platform
+     */
+    pull(customer: CustomerConfig, options?: PullOptions): Promise<PullResult<LocalIntegrationData>>;
+    /**
+     * Push changed connectors to NEWO platform
+     */
+    push(customer: CustomerConfig, changes?: ChangeItem<LocalIntegrationData>[]): Promise<PushResult>;
+    /**
+     * Check if connector has changed compared to remote version
+     */
+    private hasConnectorChanged;
+    /**
+     * Detect changes in integration files
+     */
+    getChanges(customer: CustomerConfig): Promise<ChangeItem<LocalIntegrationData>[]>;
+    /**
+     * Validate integration data
+     */
+    validate(_customer: CustomerConfig, items: LocalIntegrationData[]): Promise<ValidationResult>;
+    /**
+     * Get status summary
+     */
+    getStatus(customer: CustomerConfig): Promise<StatusSummary>;
+}
+/**
+ * Factory function for creating IntegrationSyncStrategy
+ */
+export declare function createIntegrationSyncStrategy(apiClientFactory: ApiClientFactory, logger: ILogger): IntegrationSyncStrategy;
+//# sourceMappingURL=IntegrationSyncStrategy.d.ts.map

package/dist/domain/strategies/sync/IntegrationSyncStrategy.js

@@ -0,0 +1,413 @@
+/**
+ * IntegrationSyncStrategy - Handles synchronization of Integrations, Connectors, and Webhooks
+ *
+ * This strategy implements ISyncStrategy for the Integrations resource.
+ *
+ * Key responsibilities:
+ * - Pull integrations from NEWO platform
+ * - Pull connectors for each integration
+ * - Pull webhooks (outgoing and incoming)
+ * - Push connector changes back to platform
+ * - Detect changes using stored hashes
+ */
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+import path from 'path';
+import { listIntegrations, listConnectors, getIntegrationSettings, createConnector, updateConnector, deleteConnector, listOutgoingWebhooks, listIncomingWebhooks } from '../../../api.js';
+import { sha256, saveHashes, loadHashes } from '../../../hash.js';
+/**
+ * IntegrationSyncStrategy - Handles integration synchronization
+ */
+export class IntegrationSyncStrategy {
+    apiClientFactory;
+    logger;
+    resourceType = 'integrations';
+    displayName = 'Integrations';
+    constructor(apiClientFactory, logger) {
+        this.apiClientFactory = apiClientFactory;
+        this.logger = logger;
+    }
+    /**
+     * Pull all integrations from NEWO platform
+     */
+    async pull(customer, options = {}) {
+        const client = await this.apiClientFactory(customer, options.verbose ?? false);
+        const hashes = {};
+        const items = [];
+        this.logger.verbose(`🔍 Fetching integrations for ${customer.idn}...`);
+        const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+        const integrationsDir = path.join(customerDir, 'integrations');
+        await fs.ensureDir(integrationsDir);
+        // Fetch all integrations
+        const integrations = await listIntegrations(client);
+        this.logger.verbose(`📦 Found ${integrations.length} integrations`);
+        const integrationsMetadata = [];
+        // Fetch webhooks once for all integrations
+        let allOutgoingWebhooks = [];
+        let allIncomingWebhooks = [];
+        try {
+            allOutgoingWebhooks = await listOutgoingWebhooks(client);
+            allIncomingWebhooks = await listIncomingWebhooks(client);
+            this.logger.verbose(`📡 Found ${allOutgoingWebhooks.length} outgoing, ${allIncomingWebhooks.length} incoming webhooks`);
+        }
+        catch (error) {
+            this.logger.warn('Could not fetch webhooks');
+        }
+        // Group webhooks by connector_idn
+        const outgoingByConnector = new Map();
+        const incomingByConnector = new Map();
+        allOutgoingWebhooks.forEach(webhook => {
+            if (!outgoingByConnector.has(webhook.connector_idn)) {
+                outgoingByConnector.set(webhook.connector_idn, []);
+            }
+            outgoingByConnector.get(webhook.connector_idn).push(webhook);
+        });
+        allIncomingWebhooks.forEach(webhook => {
+            if (!incomingByConnector.has(webhook.connector_idn)) {
+                incomingByConnector.set(webhook.connector_idn, []);
+            }
+            incomingByConnector.get(webhook.connector_idn).push(webhook);
+        });
+        // Process each integration
+        for (const integration of integrations) {
+            this.logger.verbose(`  📦 Processing: ${integration.title} (${integration.idn})`);
+            const metadata = {
+                id: integration.id,
+                idn: integration.idn,
+                title: integration.title,
+                description: integration.description,
+                channel: integration.channel,
+                is_disabled: integration.is_disabled
+            };
+            integrationsMetadata.push(metadata);
+            // Create integration directory
+            const integrationDir = path.join(integrationsDir, integration.idn);
+            await fs.ensureDir(integrationDir);
+            // Fetch integration settings
+            let integrationSettings = [];
+            try {
+                integrationSettings = await getIntegrationSettings(client, integration.id);
+            }
+            catch (_error) {
+                // Settings endpoint may not be available for all integrations
+            }
+            // Save combined integration file (metadata + settings)
+            const integrationData = {
+                id: integration.id,
+                idn: integration.idn,
+                title: integration.title,
+                description: integration.description,
+                channel: integration.channel,
+                is_disabled: integration.is_disabled
+            };
+            if (integrationSettings.length > 0) {
+                integrationData.settings = integrationSettings;
+            }
+            const integrationFile = path.join(integrationDir, `${integration.idn}.yaml`);
+            const integrationYaml = yaml.dump(integrationData, { lineWidth: -1 });
+            await fs.writeFile(integrationFile, integrationYaml);
+            hashes[integrationFile] = sha256(integrationYaml);
+            // Fetch and save connectors
+            const connectors = await listConnectors(client, integration.id);
+            const connectorMetadatas = [];
+            if (connectors.length > 0) {
+                const connectorsDir = path.join(integrationDir, 'connectors');
+                await fs.ensureDir(connectorsDir);
+                for (const connector of connectors) {
+                    const connectorMetadata = {
+                        id: connector.id,
+                        connector_idn: connector.connector_idn,
+                        title: connector.title,
+                        status: connector.status,
+                        integration_idn: integration.idn,
+                        settings: connector.settings
+                    };
+                    connectorMetadatas.push(connectorMetadata);
+                    // Create subdirectory for this connector
+                    const connectorDir = path.join(connectorsDir, connector.connector_idn);
+                    await fs.ensureDir(connectorDir);
+                    // Save connector YAML file
+                    const connectorFile = path.join(connectorDir, `${connector.connector_idn}.yaml`);
+                    const connectorYaml = yaml.dump(connectorMetadata, { lineWidth: -1 });
+                    await fs.writeFile(connectorFile, connectorYaml);
+                    hashes[connectorFile] = sha256(connectorYaml);
+                    // Save webhooks if any
+                    const outgoing = outgoingByConnector.get(connector.connector_idn) || [];
+                    const incoming = incomingByConnector.get(connector.connector_idn) || [];
+                    if (outgoing.length > 0 || incoming.length > 0) {
+                        const webhooksDir = path.join(connectorDir, 'webhooks');
+                        await fs.ensureDir(webhooksDir);
+                        if (outgoing.length > 0) {
+                            const outgoingFile = path.join(webhooksDir, 'outgoing.yaml');
+                            const outgoingYaml = yaml.dump({ webhooks: outgoing }, { lineWidth: -1 });
+                            await fs.writeFile(outgoingFile, outgoingYaml);
+                            hashes[outgoingFile] = sha256(outgoingYaml);
+                        }
+                        if (incoming.length > 0) {
+                            const incomingFile = path.join(webhooksDir, 'incoming.yaml');
+                            const incomingYaml = yaml.dump({ webhooks: incoming }, { lineWidth: -1 });
+                            await fs.writeFile(incomingFile, incomingYaml);
+                            hashes[incomingFile] = sha256(incomingYaml);
+                        }
+                    }
+                    this.logger.verbose(`    ✓ Saved: ${connector.title}`);
+                }
+            }
+            items.push({
+                integration: metadata,
+                connectors: connectorMetadatas,
+                outgoingWebhooks: allOutgoingWebhooks.filter(w => connectorMetadatas.some(c => c.connector_idn === w.connector_idn)),
+                incomingWebhooks: allIncomingWebhooks.filter(w => connectorMetadatas.some(c => c.connector_idn === w.connector_idn))
+            });
+        }
+        // Save master integrations list
+        const integrationsFile = path.join(integrationsDir, 'integrations.yaml');
+        const integrationsYaml = yaml.dump({ integrations: integrationsMetadata }, { lineWidth: -1 });
+        await fs.writeFile(integrationsFile, integrationsYaml);
+        hashes[integrationsFile] = sha256(integrationsYaml);
+        // Save hashes
+        const existingHashes = await loadHashes(customer.idn);
+        await saveHashes({ ...existingHashes, ...hashes }, customer.idn);
+        this.logger.info(`✅ Saved ${integrations.length} integrations`);
+        return {
+            items,
+            count: items.length,
+            hashes
+        };
+    }
+    /**
+     * Push changed connectors to NEWO platform
+     */
+    async push(customer, changes) {
+        const result = { created: 0, updated: 0, deleted: 0, errors: [] };
+        if (!changes) {
+            changes = await this.getChanges(customer);
+        }
+        if (changes.length === 0) {
+            return result;
+        }
+        const client = await this.apiClientFactory(customer, false);
+        const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+        const integrationsDir = path.join(customerDir, 'integrations');
+        // Load remote integrations for ID mapping
+        const remoteIntegrations = await listIntegrations(client);
+        const integrationMap = new Map(); // idn -> id
+        remoteIntegrations.forEach(int => integrationMap.set(int.idn, int.id));
+        // Read integration folders
+        const integrationFolders = await fs.readdir(integrationsDir);
+        for (const folder of integrationFolders) {
+            if (folder === 'integrations.yaml')
+                continue;
+            const integrationDir = path.join(integrationsDir, folder);
+            const stat = await fs.stat(integrationDir);
+            if (!stat.isDirectory())
+                continue;
+            const integrationIdn = folder;
+            const integrationId = integrationMap.get(integrationIdn);
+            if (!integrationId) {
+                this.logger.warn(`Integration ${integrationIdn} not found on platform, skipping...`);
+                continue;
+            }
+            // Process connectors
+            const connectorsDir = path.join(integrationDir, 'connectors');
+            if (await fs.pathExists(connectorsDir)) {
+                const remoteConnectors = await listConnectors(client, integrationId);
+                const remoteConnectorMap = new Map();
+                remoteConnectors.forEach(conn => remoteConnectorMap.set(conn.connector_idn, conn));
+                const connectorDirs = await fs.readdir(connectorsDir);
+                const localConnectorIdns = new Set();
+                for (const connectorDirName of connectorDirs) {
+                    const connectorPath = path.join(connectorsDir, connectorDirName);
+                    const stat = await fs.stat(connectorPath);
+                    if (!stat.isDirectory())
+                        continue;
+                    const connectorFile = path.join(connectorPath, `${connectorDirName}.yaml`);
+                    if (!await fs.pathExists(connectorFile))
+                        continue;
+                    const connectorData = yaml.load(await fs.readFile(connectorFile, 'utf-8'));
+                    localConnectorIdns.add(connectorData.connector_idn);
+                    const remoteConnector = remoteConnectorMap.get(connectorData.connector_idn);
+                    if (!remoteConnector) {
+                        // Create new connector
+                        try {
+                            await createConnector(client, integrationId, {
+                                title: connectorData.title,
+                                connector_idn: connectorData.connector_idn,
+                                integration_idn: integrationIdn,
+                                settings: connectorData.settings
+                            });
+                            result.created++;
+                            this.logger.info(`  ✓ Created connector: ${connectorData.title}`);
+                        }
+                        catch (error) {
+                            result.errors.push(`Failed to create connector ${connectorData.connector_idn}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    else if (this.hasConnectorChanged(remoteConnector, connectorData)) {
+                        // Update connector
+                        try {
+                            await updateConnector(client, remoteConnector.id, {
+                                title: connectorData.title,
+                                status: connectorData.status,
+                                settings: connectorData.settings
+                            });
+                            result.updated++;
+                            this.logger.info(`  ✓ Updated connector: ${connectorData.title}`);
+                        }
+                        catch (error) {
+                            result.errors.push(`Failed to update connector ${connectorData.connector_idn}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                }
+                // Delete connectors that exist remotely but not locally
+                for (const [connectorIdn, remoteConnector] of remoteConnectorMap) {
+                    if (!localConnectorIdns.has(connectorIdn)) {
+                        try {
+                            await deleteConnector(client, remoteConnector.id);
+                            result.deleted++;
+                            this.logger.info(`  ✓ Deleted connector: ${remoteConnector.title}`);
+                        }
+                        catch (error) {
+                            result.errors.push(`Failed to delete connector ${connectorIdn}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Check if connector has changed compared to remote version
+     */
+    hasConnectorChanged(remote, local) {
+        if (remote.title !== local.title)
+            return true;
+        if (remote.status !== local.status)
+            return true;
+        if (remote.settings.length !== local.settings.length)
+            return true;
+        const remoteSettingsMap = new Map();
+        remote.settings.forEach(s => remoteSettingsMap.set(s.idn, s.value));
+        for (const localSetting of local.settings) {
+            const remoteValue = remoteSettingsMap.get(localSetting.idn);
+            if (remoteValue !== localSetting.value)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Detect changes in integration files
+     */
+    async getChanges(customer) {
+        const changes = [];
+        const hashes = await loadHashes(customer.idn);
+        const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+        const integrationsDir = path.join(customerDir, 'integrations');
+        if (!await fs.pathExists(integrationsDir)) {
+            return changes;
+        }
+        const integrationFolders = await fs.readdir(integrationsDir);
+        for (const folder of integrationFolders) {
+            if (folder === 'integrations.yaml')
+                continue;
+            const integrationDir = path.join(integrationsDir, folder);
+            const stat = await fs.stat(integrationDir);
+            if (!stat.isDirectory())
+                continue;
+            // Check integration file
+            const integrationFile = path.join(integrationDir, `${folder}.yaml`);
+            if (await fs.pathExists(integrationFile)) {
+                const content = await fs.readFile(integrationFile, 'utf-8');
+                const currentHash = sha256(content);
+                const storedHash = hashes[integrationFile];
+                if (storedHash !== currentHash) {
+                    changes.push({
+                        item: {
+                            integration: yaml.load(content),
+                            connectors: [],
+                            outgoingWebhooks: [],
+                            incomingWebhooks: []
+                        },
+                        operation: storedHash ? 'modified' : 'created',
+                        path: integrationFile
+                    });
+                }
+            }
+            // Check connector files
+            const connectorsDir = path.join(integrationDir, 'connectors');
+            if (await fs.pathExists(connectorsDir)) {
+                const connectorDirs = await fs.readdir(connectorsDir);
+                for (const connectorDirName of connectorDirs) {
+                    const connectorPath = path.join(connectorsDir, connectorDirName);
+                    const stat = await fs.stat(connectorPath);
+                    if (!stat.isDirectory())
+                        continue;
+                    const connectorFile = path.join(connectorPath, `${connectorDirName}.yaml`);
+                    if (await fs.pathExists(connectorFile)) {
+                        const content = await fs.readFile(connectorFile, 'utf-8');
+                        const currentHash = sha256(content);
+                        const storedHash = hashes[connectorFile];
+                        if (storedHash !== currentHash) {
+                            changes.push({
+                                item: {
+                                    integration: { id: '', idn: folder, title: '', description: '', channel: '', is_disabled: false },
+                                    connectors: [yaml.load(content)],
+                                    outgoingWebhooks: [],
+                                    incomingWebhooks: []
+                                },
+                                operation: storedHash ? 'modified' : 'created',
+                                path: connectorFile
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return changes;
+    }
+    /**
+     * Validate integration data
+     */
+    async validate(_customer, items) {
+        const errors = [];
+        for (const item of items) {
+            if (!item.integration.idn) {
+                errors.push({
+                    field: 'idn',
+                    message: 'Integration IDN is required'
+                });
+            }
+            for (const connector of item.connectors) {
+                if (!connector.connector_idn) {
+                    errors.push({
+                        field: 'connector_idn',
+                        message: 'Connector IDN is required'
+                    });
+                }
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    /**
+     * Get status summary
+     */
+    async getStatus(customer) {
+        const changes = await this.getChanges(customer);
+        return {
+            resourceType: this.resourceType,
+            displayName: this.displayName,
+            changedCount: changes.length,
+            changes: changes.map(c => ({
+                path: c.path,
+                operation: c.operation
+            }))
+        };
+    }
+}
+/**
+ * Factory function for creating IntegrationSyncStrategy
+ */
+export function createIntegrationSyncStrategy(apiClientFactory, logger) {
+    return new IntegrationSyncStrategy(apiClientFactory, logger);
+}
+//# sourceMappingURL=IntegrationSyncStrategy.js.map