newo 3.3.3 → 3.4.1

package/src/application/sync/SyncEngine.ts

@@ -0,0 +1,467 @@
+/**
+ * SyncEngine - Core synchronization orchestrator
+ *
+ * This is the central engine that coordinates sync operations across all resource types.
+ * It uses the Strategy pattern to handle different resources uniformly.
+ *
+ * Key benefits:
+ * - One engine handles projects, integrations, AKB, attributes, conversations
+ * - Adding new resource = implement one strategy class
+ * - No duplicate pull/push logic
+ * - Easy to test (mock strategies)
+ */
+
+import type {
+  ISyncStrategy,
+  PullOptions,
+  PullResult,
+  PushResult,
+  StatusSummary,
+  ValidationResult
+} from '../../domain/strategies/sync/ISyncStrategy.js';
+import type { CustomerConfig, ILogger } from '../../domain/resources/common/types.js';
+
+/**
+ * Combined pull result from all strategies
+ */
+export interface SyncPullResult {
+  customer: string;
+  resources: Array<{
+    resourceType: string;
+    displayName: string;
+    result: PullResult;
+  }>;
+  totalItems: number;
+  errors: string[];
+}
+
+/**
+ * Combined push result from all strategies
+ */
+export interface SyncPushResult {
+  customer: string;
+  resources: Array<{
+    resourceType: string;
+    displayName: string;
+    result: PushResult;
+  }>;
+  totalCreated: number;
+  totalUpdated: number;
+  totalDeleted: number;
+  errors: string[];
+}
+
+/**
+ * Status report for all resources
+ */
+export interface StatusReport {
+  customer: string;
+  resources: StatusSummary[];
+  totalChanges: number;
+}
+
+/**
+ * Sync error with context
+ */
+export class SyncError extends Error {
+  constructor(
+    message: string,
+    public resourceType: string,
+    public override cause?: Error
+  ) {
+    super(message);
+    this.name = 'SyncError';
+  }
+}
+
+/**
+ * Validation error with details
+ */
+export class ValidationError extends Error {
+  constructor(
+    message: string,
+    public results: ValidationResult[]
+  ) {
+    super(message);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * SyncEngine Options
+ */
+export interface SyncEngineOptions {
+  /**
+   * Stop on first error instead of continuing
+   */
+  stopOnError?: boolean;
+
+  /**
+   * Run strategies in parallel where possible
+   */
+  parallel?: boolean;
+}
+
+/**
+ * SyncEngine - Generic synchronization orchestrator
+ *
+ * Orchestrates pull/push/status operations across all registered strategies.
+ */
+export class SyncEngine {
+  private strategies: Map<string, ISyncStrategy> = new Map();
+
+  constructor(
+    strategies: ISyncStrategy[],
+    private logger: ILogger,
+    private options: SyncEngineOptions = {}
+  ) {
+    for (const strategy of strategies) {
+      this.strategies.set(strategy.resourceType, strategy);
+    }
+  }
+
+  /**
+   * Register a new strategy
+   */
+  registerStrategy(strategy: ISyncStrategy): void {
+    this.strategies.set(strategy.resourceType, strategy);
+  }
+
+  /**
+   * Get a specific strategy by resource type
+   */
+  getStrategy(resourceType: string): ISyncStrategy | undefined {
+    return this.strategies.get(resourceType);
+  }
+
+  /**
+   * Get all registered strategies
+   */
+  getStrategies(): ISyncStrategy[] {
+    return Array.from(this.strategies.values());
+  }
+
+  /**
+   * Pull ALL resources using registered strategies
+   */
+  async pullAll(customer: CustomerConfig, options: PullOptions = {}): Promise<SyncPullResult> {
+    this.logger.info(`📥 Pulling all resources for customer: ${customer.idn}`);
+
+    const result: SyncPullResult = {
+      customer: customer.idn,
+      resources: [],
+      totalItems: 0,
+      errors: []
+    };
+
+    const strategies = Array.from(this.strategies.values());
+
+    if (this.options.parallel) {
+      // Parallel execution
+      const pullPromises = strategies.map(async (strategy) => {
+        try {
+          return await this.pullWithStrategy(strategy, customer, options);
+        } catch (error) {
+          const message = `Failed to pull ${strategy.displayName}: ${error instanceof Error ? error.message : String(error)}`;
+          if (this.options.stopOnError) {
+            throw new SyncError(message, strategy.resourceType, error instanceof Error ? error : undefined);
+          }
+          result.errors.push(message);
+          return null;
+        }
+      });
+
+      const pullResults = await Promise.all(pullPromises);
+
+      for (const pullResult of pullResults) {
+        if (pullResult) {
+          result.resources.push(pullResult);
+          result.totalItems += pullResult.result.count;
+        }
+      }
+    } else {
+      // Sequential execution
+      for (const strategy of strategies) {
+        this.logger.info(`  📦 Pulling ${strategy.displayName}...`);
+
+        try {
+          const pullResult = await this.pullWithStrategy(strategy, customer, options);
+          result.resources.push(pullResult);
+          result.totalItems += pullResult.result.count;
+          this.logger.info(`    ✅ Pulled ${pullResult.result.count} ${strategy.displayName}`);
+        } catch (error) {
+          const message = `Failed to pull ${strategy.displayName}: ${error instanceof Error ? error.message : String(error)}`;
+          this.logger.error(message, error);
+
+          if (this.options.stopOnError) {
+            throw new SyncError(message, strategy.resourceType, error instanceof Error ? error : undefined);
+          }
+          result.errors.push(message);
+        }
+      }
+    }
+
+    this.logger.info(`✅ Pull completed: ${result.totalItems} items from ${result.resources.length} resource types`);
+
+    return result;
+  }
+
+  /**
+   * Pull specific resource types
+   */
+  async pullSelected(
+    customer: CustomerConfig,
+    resourceTypes: string[],
+    options: PullOptions = {}
+  ): Promise<SyncPullResult> {
+    this.logger.info(`📥 Pulling selected resources for customer: ${customer.idn}`);
+
+    const result: SyncPullResult = {
+      customer: customer.idn,
+      resources: [],
+      totalItems: 0,
+      errors: []
+    };
+
+    for (const resourceType of resourceTypes) {
+      const strategy = this.strategies.get(resourceType);
+
+      if (!strategy) {
+        result.errors.push(`Unknown resource type: ${resourceType}`);
+        continue;
+      }
+
+      this.logger.info(`  📦 Pulling ${strategy.displayName}...`);
+
+      try {
+        const pullResult = await this.pullWithStrategy(strategy, customer, options);
+        result.resources.push(pullResult);
+        result.totalItems += pullResult.result.count;
+        this.logger.info(`    ✅ Pulled ${pullResult.result.count} ${strategy.displayName}`);
+      } catch (error) {
+        const message = `Failed to pull ${strategy.displayName}: ${error instanceof Error ? error.message : String(error)}`;
+        this.logger.error(message, error);
+
+        if (this.options.stopOnError) {
+          throw new SyncError(message, strategy.resourceType, error instanceof Error ? error : undefined);
+        }
+        result.errors.push(message);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Push ALL changed resources using registered strategies
+   */
+  async pushAll(customer: CustomerConfig): Promise<SyncPushResult> {
+    this.logger.info(`📤 Pushing changes for customer: ${customer.idn}`);
+
+    const result: SyncPushResult = {
+      customer: customer.idn,
+      resources: [],
+      totalCreated: 0,
+      totalUpdated: 0,
+      totalDeleted: 0,
+      errors: []
+    };
+
+    for (const strategy of this.strategies.values()) {
+      this.logger.info(`  🔍 Checking changes for ${strategy.displayName}...`);
+
+      try {
+        const changes = await strategy.getChanges(customer);
+
+        if (changes.length === 0) {
+          this.logger.verbose(`    No changes for ${strategy.displayName}`);
+          continue;
+        }
+
+        this.logger.info(`    Found ${changes.length} changes in ${strategy.displayName}`);
+
+        // Validate before push
+        const items = changes.map(c => c.item);
+        const validation = await strategy.validate(customer, items);
+
+        if (!validation.valid) {
+          const errorMessages = validation.errors.map(e => `${e.field}: ${e.message}`).join(', ');
+          throw new ValidationError(`Validation failed: ${errorMessages}`, [validation]);
+        }
+
+        // Push changes
+        const pushResult = await strategy.push(customer, changes);
+
+        result.resources.push({
+          resourceType: strategy.resourceType,
+          displayName: strategy.displayName,
+          result: pushResult
+        });
+
+        result.totalCreated += pushResult.created;
+        result.totalUpdated += pushResult.updated;
+        result.totalDeleted += pushResult.deleted;
+        result.errors.push(...pushResult.errors);
+
+        this.logger.info(`    ✅ Pushed: ${pushResult.created} created, ${pushResult.updated} updated, ${pushResult.deleted} deleted`);
+      } catch (error) {
+        const message = `Failed to push ${strategy.displayName}: ${error instanceof Error ? error.message : String(error)}`;
+        this.logger.error(message, error);
+
+        if (this.options.stopOnError) {
+          throw new SyncError(message, strategy.resourceType, error instanceof Error ? error : undefined);
+        }
+        result.errors.push(message);
+      }
+    }
+
+    this.logger.info(`✅ Push completed: ${result.totalCreated} created, ${result.totalUpdated} updated, ${result.totalDeleted} deleted`);
+
+    return result;
+  }
+
+  /**
+   * Push specific resource types
+   */
+  async pushSelected(customer: CustomerConfig, resourceTypes: string[]): Promise<SyncPushResult> {
+    this.logger.info(`📤 Pushing selected resources for customer: ${customer.idn}`);
+
+    const result: SyncPushResult = {
+      customer: customer.idn,
+      resources: [],
+      totalCreated: 0,
+      totalUpdated: 0,
+      totalDeleted: 0,
+      errors: []
+    };
+
+    for (const resourceType of resourceTypes) {
+      const strategy = this.strategies.get(resourceType);
+
+      if (!strategy) {
+        result.errors.push(`Unknown resource type: ${resourceType}`);
+        continue;
+      }
+
+      try {
+        const changes = await strategy.getChanges(customer);
+
+        if (changes.length === 0) {
+          continue;
+        }
+
+        // Validate before push
+        const items = changes.map(c => c.item);
+        const validation = await strategy.validate(customer, items);
+
+        if (!validation.valid) {
+          const errorMessages = validation.errors.map(e => `${e.field}: ${e.message}`).join(', ');
+          throw new ValidationError(`Validation failed: ${errorMessages}`, [validation]);
+        }
+
+        const pushResult = await strategy.push(customer, changes);
+
+        result.resources.push({
+          resourceType: strategy.resourceType,
+          displayName: strategy.displayName,
+          result: pushResult
+        });
+
+        result.totalCreated += pushResult.created;
+        result.totalUpdated += pushResult.updated;
+        result.totalDeleted += pushResult.deleted;
+        result.errors.push(...pushResult.errors);
+      } catch (error) {
+        const message = `Failed to push ${strategy.displayName}: ${error instanceof Error ? error.message : String(error)}`;
+        this.logger.error(message, error);
+
+        if (this.options.stopOnError) {
+          throw new SyncError(message, strategy.resourceType, error instanceof Error ? error : undefined);
+        }
+        result.errors.push(message);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Get status for ALL resources
+   */
+  async getStatus(customer: CustomerConfig): Promise<StatusReport> {
+    const report: StatusReport = {
+      customer: customer.idn,
+      resources: [],
+      totalChanges: 0
+    };
+
+    for (const strategy of this.strategies.values()) {
+      try {
+        const status = await strategy.getStatus(customer);
+        report.resources.push(status);
+        report.totalChanges += status.changedCount;
+      } catch (error) {
+        this.logger.error(`Failed to get status for ${strategy.displayName}`, error);
+      }
+    }
+
+    return report;
+  }
+
+  /**
+   * Get status for specific resource types
+   */
+  async getStatusSelected(customer: CustomerConfig, resourceTypes: string[]): Promise<StatusReport> {
+    const report: StatusReport = {
+      customer: customer.idn,
+      resources: [],
+      totalChanges: 0
+    };
+
+    for (const resourceType of resourceTypes) {
+      const strategy = this.strategies.get(resourceType);
+
+      if (!strategy) {
+        continue;
+      }
+
+      try {
+        const status = await strategy.getStatus(customer);
+        report.resources.push(status);
+        report.totalChanges += status.changedCount;
+      } catch (error) {
+        this.logger.error(`Failed to get status for ${strategy.displayName}`, error);
+      }
+    }
+
+    return report;
+  }
+
+  /**
+   * Helper to execute pull with a single strategy
+   */
+  private async pullWithStrategy(
+    strategy: ISyncStrategy,
+    customer: CustomerConfig,
+    options: PullOptions
+  ): Promise<{ resourceType: string; displayName: string; result: PullResult }> {
+    const result = await strategy.pull(customer, options);
+
+    return {
+      resourceType: strategy.resourceType,
+      displayName: strategy.displayName,
+      result
+    };
+  }
+}
+
+/**
+ * Factory function for creating SyncEngine with default strategies
+ */
+export function createSyncEngine(
+  strategies: ISyncStrategy[],
+  logger: ILogger,
+  options?: SyncEngineOptions
+): SyncEngine {
+  return new SyncEngine(strategies, logger, options);
+}

package/src/application/sync/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Sync Application Layer Exports
+ */
+
+export * from './SyncEngine.js';

package/src/cli/commands/add-project.ts

@@ -0,0 +1,159 @@
+/**
+ * Add Project from Registry Command Handler - Installs a project template from registry
+ */
+import { makeClient, listRegistries, listRegistryItems, addProjectFromRegistry } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { requireSingleCustomer } from '../customer-selection.js';
+import type { MultiCustomerConfig, CliArgs, Registry, RegistryItem, AddProjectFromRegistryRequest } from '../../types.js';
+
+export async function handleAddProjectCommand(
+  customerConfig: MultiCustomerConfig,
+  args: CliArgs,
+  verbose: boolean = false
+): Promise<void> {
+  try {
+    const selectedCustomer = requireSingleCustomer(customerConfig, args.customer as string | undefined);
+
+    // Parse arguments
+    const projectIdn = args._[1] as string;
+    const registryIdn = args.registry as string || 'production';
+    const registryItemIdn = args.item as string;
+    const registryItemVersion = args.version as string | null || null;
+    const title = args.title as string || projectIdn || registryItemIdn;
+    const description = args.description as string || '';
+    const isAutoUpdateEnabled = Boolean(args['auto-update']);
+
+    // Validate required arguments
+    if (!registryItemIdn) {
+      console.error('Error: Registry item IDN is required');
+      console.error('');
+      console.error('Usage: newo add-project <project-idn> --item <registry-item-idn> [options]');
+      console.error('');
+      console.error('Options:');
+      console.error('  --item <idn>           Registry item/template IDN (required)');
+      console.error('  --registry <idn>       Registry to use (default: production)');
+      console.error('  --version <version>    Specific version to install (default: latest)');
+      console.error('  --title <title>        Project title (default: project IDN)');
+      console.error('  --description <desc>   Project description');
+      console.error('  --auto-update          Enable automatic updates from registry');
+      console.error('');
+      console.error('Examples:');
+      console.error('  newo add-project my_weather --item weather_integration');
+      console.error('  newo add-project my_calcom --item cal_com_integration --registry production');
+      console.error('  newo add-project my_zoho --item zoho_integration --version 1.0.2 --auto-update');
+      console.error('');
+      console.error('Run "newo list-registries" to see available registries');
+      console.error('Run "newo list-registry-items <registry-idn>" to see available project templates');
+      process.exit(1);
+    }
+
+    // Use registry item IDN as project IDN if not specified
+    const finalProjectIdn = projectIdn || registryItemIdn;
+
+    if (verbose) {
+      console.log(`📦 Adding project from registry`);
+      console.log(`   Project IDN: ${finalProjectIdn}`);
+      console.log(`   Title: ${title}`);
+      console.log(`   Registry: ${registryIdn}`);
+      console.log(`   Item: ${registryItemIdn}`);
+      console.log(`   Version: ${registryItemVersion || 'latest'}`);
+      console.log(`   Auto-update: ${isAutoUpdateEnabled}`);
+      console.log(`   Customer: ${selectedCustomer.idn}`);
+    }
+
+    // Get access token and create client
+    const accessToken = await getValidAccessToken(selectedCustomer);
+    const client = await makeClient(verbose, accessToken);
+
+    // Validate registry exists
+    console.log(`🔍 Validating registry "${registryIdn}"...`);
+    const registries = await listRegistries(client);
+    const registry = registries.find((r: Registry) => r.idn === registryIdn);
+
+    if (!registry) {
+      console.error(`❌ Registry "${registryIdn}" not found`);
+      console.error('');
+      console.error('Available registries:');
+      for (const r of registries) {
+        console.error(`  • ${r.idn}`);
+      }
+      process.exit(1);
+    }
+
+    // Validate registry item exists and find version
+    console.log(`🔍 Validating project template "${registryItemIdn}"...`);
+    const items = await listRegistryItems(client, registry.id);
+    const matchingItems = items.filter((item: RegistryItem) => item.idn === registryItemIdn);
+
+    if (matchingItems.length === 0) {
+      console.error(`❌ Project template "${registryItemIdn}" not found in "${registryIdn}" registry`);
+      console.error('');
+      console.error('Run "newo list-registry-items ' + registryIdn + '" to see available templates');
+      process.exit(1);
+    }
+
+    // Find the specific version or latest
+    let selectedItem: RegistryItem | undefined;
+    if (registryItemVersion) {
+      selectedItem = matchingItems.find((item: RegistryItem) => item.version === registryItemVersion);
+      if (!selectedItem) {
+        console.error(`❌ Version "${registryItemVersion}" not found for "${registryItemIdn}"`);
+        console.error('');
+        console.error('Available versions:');
+        const sortedItems = [...matchingItems].sort((a, b) =>
+          new Date(b.published_at).getTime() - new Date(a.published_at).getTime()
+        );
+        for (const item of sortedItems.slice(0, 10)) {
+          console.error(`  • ${item.version} (published: ${new Date(item.published_at).toISOString().split('T')[0]})`);
+        }
+        if (sortedItems.length > 10) {
+          console.error(`  ... and ${sortedItems.length - 10} more`);
+        }
+        process.exit(1);
+      }
+    } else {
+      // Get latest version (sorted by published_at desc)
+      const sortedItems = [...matchingItems].sort((a, b) =>
+        new Date(b.published_at).getTime() - new Date(a.published_at).getTime()
+      );
+      selectedItem = sortedItems[0];
+    }
+
+    if (!selectedItem) {
+      console.error(`❌ Could not determine version for "${registryItemIdn}"`);
+      process.exit(1);
+    }
+
+    console.log(`📥 Installing "${registryItemIdn}" v${selectedItem.version} as "${finalProjectIdn}"...`);
+
+    // Create project from registry
+    const projectData: AddProjectFromRegistryRequest = {
+      idn: finalProjectIdn,
+      title,
+      version: '',
+      description,
+      is_auto_update_enabled: isAutoUpdateEnabled,
+      registry_idn: registryIdn,
+      registry_item_idn: registryItemIdn,
+      registry_item_version: registryItemVersion
+    };
+
+    const response = await addProjectFromRegistry(client, projectData);
+
+    console.log('');
+    console.log(`✅ Project installed successfully!`);
+    console.log(`   Project IDN: ${finalProjectIdn}`);
+    console.log(`   Project ID: ${response.id}`);
+    console.log(`   Source: ${registryItemIdn} v${selectedItem.version}`);
+    console.log(`   Registry: ${registryIdn}`);
+    if (isAutoUpdateEnabled) {
+      console.log(`   Auto-update: Enabled`);
+    }
+    console.log('');
+    console.log(`💡 Run "newo pull" to sync the project locally`);
+
+  } catch (error: unknown) {
+    console.error('❌ Failed to add project from registry:', error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}