newo 3.3.3 → 3.4.1

package/dist/application/sync/SyncEngine.d.ts

@@ -0,0 +1,134 @@
+/**
+ * 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 declare class SyncError extends Error {
+    resourceType: string;
+    cause?: Error | undefined;
+    constructor(message: string, resourceType: string, cause?: Error | undefined);
+}
+/**
+ * Validation error with details
+ */
+export declare class ValidationError extends Error {
+    results: ValidationResult[];
+    constructor(message: string, results: ValidationResult[]);
+}
+/**
+ * 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 declare class SyncEngine {
+    private logger;
+    private options;
+    private strategies;
+    constructor(strategies: ISyncStrategy[], logger: ILogger, options?: SyncEngineOptions);
+    /**
+     * Register a new strategy
+     */
+    registerStrategy(strategy: ISyncStrategy): void;
+    /**
+     * Get a specific strategy by resource type
+     */
+    getStrategy(resourceType: string): ISyncStrategy | undefined;
+    /**
+     * Get all registered strategies
+     */
+    getStrategies(): ISyncStrategy[];
+    /**
+     * Pull ALL resources using registered strategies
+     */
+    pullAll(customer: CustomerConfig, options?: PullOptions): Promise<SyncPullResult>;
+    /**
+     * Pull specific resource types
+     */
+    pullSelected(customer: CustomerConfig, resourceTypes: string[], options?: PullOptions): Promise<SyncPullResult>;
+    /**
+     * Push ALL changed resources using registered strategies
+     */
+    pushAll(customer: CustomerConfig): Promise<SyncPushResult>;
+    /**
+     * Push specific resource types
+     */
+    pushSelected(customer: CustomerConfig, resourceTypes: string[]): Promise<SyncPushResult>;
+    /**
+     * Get status for ALL resources
+     */
+    getStatus(customer: CustomerConfig): Promise<StatusReport>;
+    /**
+     * Get status for specific resource types
+     */
+    getStatusSelected(customer: CustomerConfig, resourceTypes: string[]): Promise<StatusReport>;
+    /**
+     * Helper to execute pull with a single strategy
+     */
+    private pullWithStrategy;
+}
+/**
+ * Factory function for creating SyncEngine with default strategies
+ */
+export declare function createSyncEngine(strategies: ISyncStrategy[], logger: ILogger, options?: SyncEngineOptions): SyncEngine;
+//# sourceMappingURL=SyncEngine.d.ts.map

package/dist/application/sync/SyncEngine.js

@@ -0,0 +1,335 @@
+/**
+ * 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)
+ */
+/**
+ * Sync error with context
+ */
+export class SyncError extends Error {
+    resourceType;
+    cause;
+    constructor(message, resourceType, cause) {
+        super(message);
+        this.resourceType = resourceType;
+        this.cause = cause;
+        this.name = 'SyncError';
+    }
+}
+/**
+ * Validation error with details
+ */
+export class ValidationError extends Error {
+    results;
+    constructor(message, results) {
+        super(message);
+        this.results = results;
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * SyncEngine - Generic synchronization orchestrator
+ *
+ * Orchestrates pull/push/status operations across all registered strategies.
+ */
+export class SyncEngine {
+    logger;
+    options;
+    strategies = new Map();
+    constructor(strategies, logger, options = {}) {
+        this.logger = logger;
+        this.options = options;
+        for (const strategy of strategies) {
+            this.strategies.set(strategy.resourceType, strategy);
+        }
+    }
+    /**
+     * Register a new strategy
+     */
+    registerStrategy(strategy) {
+        this.strategies.set(strategy.resourceType, strategy);
+    }
+    /**
+     * Get a specific strategy by resource type
+     */
+    getStrategy(resourceType) {
+        return this.strategies.get(resourceType);
+    }
+    /**
+     * Get all registered strategies
+     */
+    getStrategies() {
+        return Array.from(this.strategies.values());
+    }
+    /**
+     * Pull ALL resources using registered strategies
+     */
+    async pullAll(customer, options = {}) {
+        this.logger.info(`📥 Pulling all resources for customer: ${customer.idn}`);
+        const result = {
+            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, resourceTypes, options = {}) {
+        this.logger.info(`📥 Pulling selected resources for customer: ${customer.idn}`);
+        const result = {
+            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) {
+        this.logger.info(`📤 Pushing changes for customer: ${customer.idn}`);
+        const result = {
+            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, resourceTypes) {
+        this.logger.info(`📤 Pushing selected resources for customer: ${customer.idn}`);
+        const result = {
+            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) {
+        const report = {
+            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, resourceTypes) {
+        const report = {
+            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
+     */
+    async pullWithStrategy(strategy, customer, options) {
+        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, logger, options) {
+    return new SyncEngine(strategies, logger, options);
+}
+//# sourceMappingURL=SyncEngine.js.map

package/dist/application/sync/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Sync Application Layer Exports
+ */
+export * from './SyncEngine.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/application/sync/index.js

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

package/dist/cli/commands/add-project.d.ts

@@ -0,0 +1,3 @@
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+export declare function handleAddProjectCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose?: boolean): Promise<void>;
+//# sourceMappingURL=add-project.d.ts.map

package/dist/cli/commands/add-project.js

@@ -0,0 +1,136 @@
+/**
+ * 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';
+export async function handleAddProjectCommand(customerConfig, args, verbose = false) {
+    try {
+        const selectedCustomer = requireSingleCustomer(customerConfig, args.customer);
+        // Parse arguments
+        const projectIdn = args._[1];
+        const registryIdn = args.registry || 'production';
+        const registryItemIdn = args.item;
+        const registryItemVersion = args.version || null;
+        const title = args.title || projectIdn || registryItemIdn;
+        const description = args.description || '';
+        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) => 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) => 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;
+        if (registryItemVersion) {
+            selectedItem = matchingItems.find((item) => 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 = {
+            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) {
+        console.error('❌ Failed to add project from registry:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=add-project.js.map

package/dist/cli/commands/create-customer.d.ts

@@ -0,0 +1,3 @@
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+export declare function handleCreateCustomerCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose?: boolean): Promise<void>;
+//# sourceMappingURL=create-customer.d.ts.map