newo 3.4.0 → 3.4.2

package/src/domain/strategies/sync/AttributeSyncStrategy.ts

@@ -0,0 +1,508 @@
+/**
+ * AttributeSyncStrategy - Handles synchronization of Customer and Project Attributes
+ *
+ * This strategy implements ISyncStrategy for the Attributes resource.
+ *
+ * Key responsibilities:
+ * - Pull customer attributes from NEWO platform
+ * - Pull project attributes for all projects
+ * - Push changed attributes back to platform
+ * - Detect changes using stored hashes
+ */
+
+import type {
+  ISyncStrategy,
+  PullOptions,
+  PullResult,
+  PushResult,
+  ChangeItem,
+  ValidationResult,
+  ValidationError,
+  StatusSummary
+} from './ISyncStrategy.js';
+import type { CustomerConfig, ILogger, HashStore } from '../../resources/common/types.js';
+import type { AxiosInstance } from 'axios';
+import type { CustomerAttribute, CustomerAttributesResponse } from '../../../types.js';
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+import path from 'path';
+import {
+  getCustomerAttributes,
+  getProjectAttributes,
+  updateCustomerAttribute,
+  updateProjectAttribute,
+  listProjects
+} from '../../../api.js';
+import {
+  writeFileSafe,
+  customerAttributesPath,
+  customerAttributesMapPath
+} from '../../../fsutil.js';
+import { sha256, saveHashes, loadHashes } from '../../../hash.js';
+
+/**
+ * Local attribute data for storage
+ */
+export interface LocalAttributeData {
+  type: 'customer' | 'project';
+  projectIdn?: string;
+  attributes: CustomerAttribute[];
+  idMapping: Record<string, string>;
+}
+
+/**
+ * API client factory type
+ */
+export type ApiClientFactory = (customer: CustomerConfig, verbose: boolean) => Promise<AxiosInstance>;
+
+/**
+ * AttributeSyncStrategy - Handles attribute synchronization
+ */
+export class AttributeSyncStrategy implements ISyncStrategy<CustomerAttributesResponse, LocalAttributeData> {
+  readonly resourceType = 'attributes';
+  readonly displayName = 'Attributes';
+
+  constructor(
+    private apiClientFactory: ApiClientFactory,
+    private logger: ILogger
+  ) {}
+
+  /**
+   * Pull all attributes from NEWO platform
+   */
+  async pull(customer: CustomerConfig, options: PullOptions = {}): Promise<PullResult<LocalAttributeData>> {
+    const client = await this.apiClientFactory(customer, options.verbose ?? false);
+    const hashes: HashStore = {};
+    const items: LocalAttributeData[] = [];
+
+    this.logger.verbose(`🔍 Fetching attributes for ${customer.idn}...`);
+
+    // Pull customer attributes
+    const customerAttrs = await this.pullCustomerAttributes(client, customer, hashes, options);
+    items.push(customerAttrs);
+
+    // Pull project attributes
+    const projects = await listProjects(client);
+    this.logger.verbose(`📁 Pulling attributes for ${projects.length} projects`);
+
+    for (const project of projects) {
+      try {
+        const projectAttrs = await this.pullProjectAttributes(
+          client, customer, project.id, project.idn, hashes, options
+        );
+        if (projectAttrs) {
+          items.push(projectAttrs);
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to pull attributes for project ${project.idn}`);
+      }
+    }
+
+    // Save hashes
+    const existingHashes = await loadHashes(customer.idn);
+    await saveHashes({ ...existingHashes, ...hashes }, customer.idn);
+
+    return {
+      items,
+      count: items.length,
+      hashes
+    };
+  }
+
+  /**
+   * Pull customer attributes
+   */
+  private async pullCustomerAttributes(
+    client: AxiosInstance,
+    customer: CustomerConfig,
+    hashes: HashStore,
+    options: PullOptions
+  ): Promise<LocalAttributeData> {
+    this.logger.verbose(`  📦 Fetching customer attributes...`);
+
+    const response = await getCustomerAttributes(client, true);
+    const attributes = response.attributes || [];
+
+    // Create ID mapping
+    const idMapping: Record<string, string> = {};
+    const cleanAttributes = attributes.map(attr => {
+      if (attr.id) {
+        idMapping[attr.idn] = attr.id;
+      }
+      return this.cleanAttribute(attr);
+    });
+
+    // Format as YAML
+    const yamlContent = this.formatAttributesYaml(cleanAttributes);
+
+    // Save files
+    const attributesPath = customerAttributesPath(customer.idn);
+    await writeFileSafe(attributesPath, yamlContent);
+    await writeFileSafe(customerAttributesMapPath(customer.idn), JSON.stringify(idMapping, null, 2));
+
+    hashes[attributesPath] = sha256(yamlContent);
+
+    if (options.verbose) {
+      this.logger.info(`  ✓ Saved ${cleanAttributes.length} customer attributes`);
+    }
+
+    return {
+      type: 'customer',
+      attributes: cleanAttributes,
+      idMapping
+    };
+  }
+
+  /**
+   * Pull project attributes
+   */
+  private async pullProjectAttributes(
+    client: AxiosInstance,
+    customer: CustomerConfig,
+    projectId: string,
+    projectIdn: string,
+    hashes: HashStore,
+    options: PullOptions
+  ): Promise<LocalAttributeData | null> {
+    try {
+      const response = await getProjectAttributes(client, projectId, true);
+      const attributes = response.attributes || [];
+
+      if (attributes.length === 0) {
+        return null;
+      }
+
+      // Create ID mapping
+      const idMapping: Record<string, string> = {};
+      const cleanAttributes = attributes.map(attr => {
+        if (attr.id) {
+          idMapping[attr.idn] = attr.id;
+        }
+        return this.cleanAttribute(attr);
+      });
+
+      // Format as YAML
+      const yamlContent = this.formatAttributesYaml(cleanAttributes);
+
+      // Save files
+      const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+      const projectDir = path.join(customerDir, 'projects', projectIdn);
+      await fs.ensureDir(projectDir);
+
+      const attributesFile = path.join(projectDir, 'attributes.yaml');
+      const mapFile = path.join(process.cwd(), '.newo', customer.idn, `project_${projectIdn}_attributes-map.json`);
+
+      await writeFileSafe(attributesFile, yamlContent);
+      await fs.ensureDir(path.dirname(mapFile));
+      await writeFileSafe(mapFile, JSON.stringify(idMapping, null, 2));
+
+      hashes[attributesFile] = sha256(yamlContent);
+
+      if (options.verbose) {
+        this.logger.verbose(`    ✓ Saved ${cleanAttributes.length} attributes for project ${projectIdn}`);
+      }
+
+      return {
+        type: 'project',
+        projectIdn,
+        attributes: cleanAttributes,
+        idMapping
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Clean an attribute for local storage
+   */
+  private cleanAttribute(attr: CustomerAttribute): CustomerAttribute {
+    let processedValue = attr.value;
+
+    // Handle JSON string values
+    if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+      try {
+        const parsed = JSON.parse(attr.value);
+        processedValue = JSON.stringify(parsed, null, 0);
+      } catch {
+        processedValue = attr.value;
+      }
+    }
+
+    return {
+      idn: attr.idn,
+      value: processedValue,
+      title: attr.title || '',
+      description: attr.description || '',
+      group: attr.group || '',
+      is_hidden: attr.is_hidden,
+      possible_values: attr.possible_values || [],
+      value_type: attr.value_type
+    };
+  }
+
+  /**
+   * Format attributes as YAML
+   */
+  private formatAttributesYaml(attributes: CustomerAttribute[]): string {
+    // Add enum placeholders for value_type
+    const attributesWithPlaceholders = attributes.map(attr => ({
+      ...attr,
+      value_type: `__ENUM_PLACEHOLDER_${attr.value_type}__`
+    }));
+
+    let yamlContent = yaml.dump({ attributes: attributesWithPlaceholders }, {
+      indent: 2,
+      quotingType: '"',
+      forceQuotes: false,
+      lineWidth: 80,
+      noRefs: true,
+      sortKeys: false,
+      flowLevel: -1
+    });
+
+    // Replace placeholders with enum syntax
+    yamlContent = yamlContent.replace(/__ENUM_PLACEHOLDER_(\w+)__/g, '!enum "AttributeValueTypes.$1"');
+    yamlContent = yamlContent.replace(/\\"/g, '"');
+
+    return yamlContent;
+  }
+
+  /**
+   * Push changed attributes to NEWO platform
+   */
+  async push(customer: CustomerConfig, changes?: ChangeItem<LocalAttributeData>[]): Promise<PushResult> {
+    const result: PushResult = { 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);
+
+    for (const change of changes) {
+      try {
+        if (change.item.type === 'customer') {
+          const updateCount = await this.pushCustomerAttributes(client, customer, change.item);
+          result.updated += updateCount;
+        } else if (change.item.type === 'project' && change.item.projectIdn) {
+          const updateCount = await this.pushProjectAttributes(
+            client, customer, change.item.projectIdn, change.item
+          );
+          result.updated += updateCount;
+        }
+      } catch (error) {
+        result.errors.push(`Failed to push ${change.path}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Push customer attributes
+   */
+  private async pushCustomerAttributes(
+    client: AxiosInstance,
+    customer: CustomerConfig,
+    _data: LocalAttributeData
+  ): Promise<number> {
+    // Load current attributes from file
+    const attributesFile = customerAttributesPath(customer.idn);
+    const mapFile = customerAttributesMapPath(customer.idn);
+
+    if (!(await fs.pathExists(attributesFile)) || !(await fs.pathExists(mapFile))) {
+      return 0;
+    }
+
+    let content = await fs.readFile(attributesFile, 'utf-8');
+    content = content.replace(/!enum "AttributeValueTypes\.(\w+)"/g, '$1');
+
+    const localData = yaml.load(content) as { attributes: CustomerAttribute[] };
+    const idMapping = JSON.parse(await fs.readFile(mapFile, 'utf-8')) as Record<string, string>;
+
+    // Get remote attributes
+    const remoteResponse = await getCustomerAttributes(client, true);
+    const remoteMap = new Map<string, CustomerAttribute>();
+    remoteResponse.attributes.forEach(attr => remoteMap.set(attr.idn, attr));
+
+    let updatedCount = 0;
+
+    for (const localAttr of localData.attributes) {
+      const attributeId = idMapping[localAttr.idn];
+      if (!attributeId) continue;
+
+      const remoteAttr = remoteMap.get(localAttr.idn);
+      if (!remoteAttr) continue;
+
+      if (String(localAttr.value) !== String(remoteAttr.value)) {
+        await updateCustomerAttribute(client, {
+          id: attributeId,
+          ...localAttr
+        });
+        updatedCount++;
+        this.logger.info(`  ✓ Updated customer attribute: ${localAttr.idn}`);
+      }
+    }
+
+    return updatedCount;
+  }
+
+  /**
+   * Push project attributes
+   */
+  private async pushProjectAttributes(
+    client: AxiosInstance,
+    customer: CustomerConfig,
+    projectIdn: string,
+    _data: LocalAttributeData
+  ): Promise<number> {
+    const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+    const attributesFile = path.join(customerDir, 'projects', projectIdn, 'attributes.yaml');
+    const mapFile = path.join(process.cwd(), '.newo', customer.idn, `project_${projectIdn}_attributes-map.json`);
+
+    if (!(await fs.pathExists(attributesFile)) || !(await fs.pathExists(mapFile))) {
+      return 0;
+    }
+
+    let content = await fs.readFile(attributesFile, 'utf-8');
+    content = content.replace(/!enum "AttributeValueTypes\.(\w+)"/g, '$1');
+
+    const localData = yaml.load(content) as { attributes: CustomerAttribute[] };
+    const idMapping = JSON.parse(await fs.readFile(mapFile, 'utf-8')) as Record<string, string>;
+
+    // Get project ID from projects list
+    const projects = await listProjects(client);
+    const project = projects.find(p => p.idn === projectIdn);
+    if (!project) {
+      return 0;
+    }
+
+    // Get remote attributes
+    const remoteResponse = await getProjectAttributes(client, project.id, true);
+    const remoteMap = new Map<string, CustomerAttribute>();
+    remoteResponse.attributes.forEach(attr => remoteMap.set(attr.idn, attr));
+
+    let updatedCount = 0;
+
+    for (const localAttr of localData.attributes) {
+      const attributeId = idMapping[localAttr.idn];
+      if (!attributeId) continue;
+
+      const remoteAttr = remoteMap.get(localAttr.idn);
+      if (!remoteAttr) continue;
+
+      if (String(localAttr.value) !== String(remoteAttr.value)) {
+        await updateProjectAttribute(client, project.id, {
+          id: attributeId,
+          ...localAttr
+        });
+        updatedCount++;
+        this.logger.info(`  ✓ Updated project attribute: ${projectIdn}/${localAttr.idn}`);
+      }
+    }
+
+    return updatedCount;
+  }
+
+  /**
+   * Detect changes in attribute files
+   */
+  async getChanges(customer: CustomerConfig): Promise<ChangeItem<LocalAttributeData>[]> {
+    const changes: ChangeItem<LocalAttributeData>[] = [];
+    const hashes = await loadHashes(customer.idn);
+
+    // Check customer attributes
+    const customerAttrsPath = customerAttributesPath(customer.idn);
+    if (await fs.pathExists(customerAttrsPath)) {
+      const content = await fs.readFile(customerAttrsPath, 'utf-8');
+      const currentHash = sha256(content);
+      const storedHash = hashes[customerAttrsPath];
+
+      if (storedHash !== currentHash) {
+        changes.push({
+          item: { type: 'customer', attributes: [], idMapping: {} },
+          operation: 'modified',
+          path: customerAttrsPath
+        });
+      }
+    }
+
+    // Check project attributes
+    const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn, 'projects');
+    if (await fs.pathExists(customerDir)) {
+      const projectDirs = await fs.readdir(customerDir);
+
+      for (const projectIdn of projectDirs) {
+        const attributesFile = path.join(customerDir, projectIdn, 'attributes.yaml');
+
+        if (await fs.pathExists(attributesFile)) {
+          const content = await fs.readFile(attributesFile, 'utf-8');
+          const currentHash = sha256(content);
+          const storedHash = hashes[attributesFile];
+
+          if (storedHash !== currentHash) {
+            changes.push({
+              item: { type: 'project', projectIdn, attributes: [], idMapping: {} },
+              operation: 'modified',
+              path: attributesFile
+            });
+          }
+        }
+      }
+    }
+
+    return changes;
+  }
+
+  /**
+   * Validate attribute data
+   */
+  async validate(_customer: CustomerConfig, items: LocalAttributeData[]): Promise<ValidationResult> {
+    const errors: ValidationError[] = [];
+
+    for (const item of items) {
+      for (const attr of item.attributes) {
+        if (!attr.idn) {
+          errors.push({
+            field: 'idn',
+            message: 'Attribute IDN is required'
+          });
+        }
+      }
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Get status summary
+   */
+  async getStatus(customer: CustomerConfig): Promise<StatusSummary> {
+    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 AttributeSyncStrategy
+ */
+export function createAttributeSyncStrategy(
+  apiClientFactory: ApiClientFactory,
+  logger: ILogger
+): AttributeSyncStrategy {
+  return new AttributeSyncStrategy(apiClientFactory, logger);
+}