@hasna/connectors 1.3.22 → 1.3.23

package/connectors/connect-shopify/src/cli/index.ts

@@ -866,5 +866,113 @@ collectionsCmd
     }
   });
 
+// ============================================
+// Bulk Operations Commands
+// ============================================
+const bulkCmd = program
+  .command('bulk')
+  .description('Bulk operations');
+
+bulkCmd
+  .command('products')
+  .description('Bulk product operations')
+  .requiredOption('--ids <ids>', 'Comma-separated product IDs')
+  .requiredOption('--action <action>', 'Action: delete, activate, archive')
+  .option('--concurrency <number>', 'Max concurrent operations', '10')
+  .option('--dry-run', 'Preview without executing')
+  .action(async function(this: Command, opts) {
+    try {
+      const client = getClient();
+      const result = await client.bulk.products({
+        productIds: opts.ids.split(',').map((id: string) => parseInt(id.trim())),
+        action: opts.action as 'delete' | 'activate' | 'archive',
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => info(`Progress: ${current}/${total}`),
+      });
+      print(result, getFormat(this));
+      info(`Success: ${result.success}, Failed: ${result.failed}, Total: ${result.total}`);
+      if (result.errors.length > 0) {
+        warn('Errors:');
+        result.errors.forEach(e => error(`  ${e.productId}: ${e.error}`));
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('orders')
+  .description('Bulk order operations')
+  .requiredOption('--ids <ids>', 'Comma-separated order IDs')
+  .requiredOption('--action <action>', 'Action: close, open, cancel')
+  .option('--cancel-reason <reason>', 'Cancel reason: customer, inventory, fraud, declined, other')
+  .option('--email', 'Send cancel email')
+  .option('--restock', 'Restock on cancel')
+  .option('--concurrency <number>', 'Max concurrent operations', '10')
+  .option('--dry-run', 'Preview without executing')
+  .action(async function(this: Command, opts) {
+    try {
+      const client = getClient();
+      const result = await client.bulk.orders({
+        orderIds: opts.ids.split(',').map((id: string) => parseInt(id.trim())),
+        action: opts.action as 'close' | 'open' | 'cancel',
+        cancelReason: opts.cancelReason,
+        cancelEmail: opts.email,
+        cancelRestock: opts.restock,
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => info(`Progress: ${current}/${total}`),
+      });
+      print(result, getFormat(this));
+      info(`Success: ${result.success}, Failed: ${result.failed}, Total: ${result.total}`);
+      if (result.errors.length > 0) {
+        warn('Errors:');
+        result.errors.forEach(e => error(`  ${e.orderId}: ${e.error}`));
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('inventory')
+  .description('Bulk inventory operations')
+  .requiredOption('--items <items>', 'Items as "itemId:locationId:qty" pairs, comma-separated')
+  .requiredOption('--action <action>', 'Action: set, adjust')
+  .option('--concurrency <number>', 'Max concurrent operations', '10')
+  .option('--dry-run', 'Preview without executing')
+  .action(async function(this: Command, opts) {
+    try {
+      const client = getClient();
+      const items = opts.items.split(',').map((pair: string) => {
+        const [inventoryItemId, locationId, available] = pair.trim().split(':');
+        return {
+          inventoryItemId: parseInt(inventoryItemId),
+          locationId: parseInt(locationId),
+          available: parseInt(available),
+        };
+      });
+      const result = await client.bulk.inventory({
+        items,
+        action: opts.action as 'set' | 'adjust',
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => info(`Progress: ${current}/${total}`),
+      });
+      print(result, getFormat(this));
+      info(`Success: ${result.success}, Failed: ${result.failed}, Total: ${result.total}`);
+      if (result.errors.length > 0) {
+        warn('Errors:');
+        result.errors.forEach(e => error(`  item ${e.inventoryItemId} @ location ${e.locationId}: ${e.error}`));
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
 // Parse and execute
 program.parse();

package/connectors/connect-slack/src/api/bulk.ts

@@ -0,0 +1,237 @@
+import type { SlackClient } from './client';
+
+// ============================================
+// Bulk Operation Types
+// ============================================
+
+export interface BulkOperationOptions {
+  /** Maximum concurrent API calls (default: 10) */
+  concurrency?: number;
+  /** Dry run - don't actually modify */
+  dryRun?: boolean;
+  /** Progress callback */
+  onProgress?: (current: number, total: number, item: unknown) => void;
+  /** Error callback */
+  onError?: (error: Error, item: unknown) => void;
+}
+
+// --- Channel Bulk Operations ---
+
+export interface BulkChannelOptions extends BulkOperationOptions {
+  channelIds: string[];
+  /** Action to perform */
+  action: 'archive' | 'unarchive';
+}
+
+export interface BulkChannelResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ channelId: string; error: string }>;
+  results: Array<{ channelId: string; response: unknown }>;
+}
+
+// --- Message Bulk Operations ---
+
+export interface BulkMessageOptions extends BulkOperationOptions {
+  /** Messages to delete, each with channel and timestamp */
+  messages: Array<{ channel: string; ts: string }>;
+}
+
+export interface BulkMessageResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ channel: string; ts: string; error: string }>;
+  results: Array<{ channel: string; ts: string; response: unknown }>;
+}
+
+// --- User Bulk Operations ---
+
+export interface BulkUserOptions extends BulkOperationOptions {
+  userIds: string[];
+  /** Action: set presence for all users */
+  action: 'set_presence';
+  /** Presence value: 'auto' or 'away' */
+  presence?: 'auto' | 'away';
+}
+
+export interface BulkUserResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ userId: string; error: string }>;
+  results: Array<{ userId: string; response: unknown }>;
+}
+
+// ============================================
+// Bulk Operations API
+// ============================================
+
+export class BulkApi {
+  private readonly client: SlackClient;
+
+  constructor(client: SlackClient) {
+    this.client = client;
+  }
+
+  // ============================================
+  // Bulk Channel Operations
+  // ============================================
+
+  async channels(options: BulkChannelOptions): Promise<BulkChannelResult> {
+    const { channelIds, action, concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkChannelResult = {
+      total: channelIds.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (channelIds.length === 0) return result;
+
+    const chunks = this.chunkArray(channelIds, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (channelId) => {
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              const endpoint = action === 'archive' ? 'conversations.archive' : 'conversations.unarchive';
+              const response = await this.client.post<{ ok: boolean; channel: Record<string, unknown> }>(
+                endpoint,
+                { channel: channelId }
+              );
+              result.success++;
+              result.results.push({ channelId, response });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, channelId);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ channelId, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), channelId);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Bulk Message Operations
+  // ============================================
+
+  async messages(options: BulkMessageOptions): Promise<BulkMessageResult> {
+    const { messages, concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkMessageResult = {
+      total: messages.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (messages.length === 0) return result;
+
+    const chunks = this.chunkArray(messages, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (msg) => {
+          const { channel, ts } = msg;
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              const response = await this.client.post<{ ok: boolean }>(
+                'chat.delete',
+                { channel, ts }
+              );
+              result.success++;
+              result.results.push({ channel, ts, response });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, msg);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ channel, ts, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), msg);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Bulk User Operations
+  // ============================================
+
+  async users(options: BulkUserOptions): Promise<BulkUserResult> {
+    const { userIds, action, presence = 'auto', concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkUserResult = {
+      total: userIds.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (userIds.length === 0) return result;
+
+    const chunks = this.chunkArray(userIds, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (userId) => {
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              // Slack's users.setPresence only sets the current user's presence,
+              // but we still iterate through userIds for tracking purposes
+              const response = await this.client.post<{ ok: boolean }>(
+                'users.setPresence',
+                { presence }
+              );
+              result.success++;
+              result.results.push({ userId, response });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, userId);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ userId, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), userId);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Helper Methods
+  // ============================================
+
+  private chunkArray<T>(array: T[], size: number): T[][] {
+    const chunks: T[][] = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+}

package/connectors/connect-slack/src/api/index.ts

@@ -3,11 +3,13 @@ import { SlackClient } from './client';
 import { ChannelsApi } from './channels';
 import { MessagesApi } from './messages';
 import { UsersApi } from './users';
+import { BulkApi } from './bulk';
 
 export { SlackClient } from './client';
 export { ChannelsApi } from './channels';
 export { MessagesApi } from './messages';
 export { UsersApi } from './users';
+export { BulkApi } from './bulk';
 
 /**
  * Main Slack API class
@@ -18,12 +20,14 @@ export class Slack {
   public readonly channels: ChannelsApi;
   public readonly messages: MessagesApi;
   public readonly users: UsersApi;
+  public readonly bulk: BulkApi;
 
   constructor(config: SlackConfig) {
     this.client = new SlackClient(config);
     this.channels = new ChannelsApi(this.client);
     this.messages = new MessagesApi(this.client);
     this.users = new UsersApi(this.client);
+    this.bulk = new BulkApi(this.client);
   }
 
   /**

package/connectors/connect-slack/src/cli/index.ts

@@ -491,4 +491,161 @@ program
     }
   });
 
+// ============================================
+// Bulk Operations
+// ============================================
+
+const bulkCmd = program
+  .command('bulk')
+  .description('Bulk operations');
+
+bulkCmd
+  .command('channels')
+  .description('Bulk archive/unarchive channels')
+  .option('--ids <ids>', 'Comma-separated channel IDs')
+  .option('--action <action>', 'Action: archive or unarchive', 'archive')
+  .option('--concurrency <n>', 'Max concurrent requests', '10')
+  .option('--dry-run', 'Preview without executing')
+  .action(async (opts) => {
+    try {
+      const client = getClient();
+      const format = program.opts().format as OutputFormat;
+
+      if (!opts.ids) {
+        error('--ids is required (comma-separated channel IDs)');
+        process.exit(1);
+      }
+
+      const channelIds = opts.ids.split(',').map((id: string) => id.trim()).filter(Boolean);
+
+      info(`Bulk ${opts.action} ${channelIds.length} channels (concurrency: ${opts.concurrency}, dry-run: ${!!opts.dryRun})`);
+
+      const result = await client.bulk.channels({
+        channelIds,
+        action: opts.action as 'archive' | 'unarchive',
+        concurrency: parseInt(opts.concurrency, 10),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\rProgress: ${current}/${total}`);
+        },
+      });
+
+      console.log();
+      if (format === 'json') {
+        print(result, format);
+      } else {
+        info(`Done: ${result.success} succeeded, ${result.failed} failed out of ${result.total}`);
+        if (result.errors.length > 0) {
+          error('Failures:');
+          result.errors.forEach((e: { channelId: string; error: string }) => {
+            console.error(`  - ${e.channelId}: ${e.error}`);
+          });
+        }
+      }
+    } catch (e) {
+      error((e as Error).message);
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('messages')
+  .description('Bulk delete messages')
+  .option('--messages <msgs>', 'Messages as "channel:ts" pairs, comma-separated')
+  .option('--concurrency <n>', 'Max concurrent requests', '10')
+  .option('--dry-run', 'Preview without executing')
+  .action(async (opts) => {
+    try {
+      const client = getClient();
+      const format = program.opts().format as OutputFormat;
+
+      if (!opts.messages) {
+        error('--messages is required (comma-separated "channel:ts" pairs)');
+        process.exit(1);
+      }
+
+      const messages = opts.messages.split(',').map((pair: string) => {
+        const [channel, ts] = pair.trim().split(':');
+        return { channel, ts };
+      });
+
+      info(`Bulk delete ${messages.length} messages (concurrency: ${opts.concurrency}, dry-run: ${!!opts.dryRun})`);
+
+      const result = await client.bulk.messages({
+        messages,
+        concurrency: parseInt(opts.concurrency, 10),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\rProgress: ${current}/${total}`);
+        },
+      });
+
+      console.log();
+      if (format === 'json') {
+        print(result, format);
+      } else {
+        info(`Done: ${result.success} succeeded, ${result.failed} failed out of ${result.total}`);
+        if (result.errors.length > 0) {
+          error('Failures:');
+          result.errors.forEach((e: { channel: string; ts: string; error: string }) => {
+            console.error(`  - ${e.channel}@${e.ts}: ${e.error}`);
+          });
+        }
+      }
+    } catch (e) {
+      error((e as Error).message);
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('users')
+  .description('Bulk set user presence')
+  .option('--ids <ids>', 'Comma-separated user IDs')
+  .option('--presence <value>', 'Presence: auto or away', 'auto')
+  .option('--concurrency <n>', 'Max concurrent requests', '10')
+  .option('--dry-run', 'Preview without executing')
+  .action(async (opts) => {
+    try {
+      const client = getClient();
+      const format = program.opts().format as OutputFormat;
+
+      if (!opts.ids) {
+        error('--ids is required (comma-separated user IDs)');
+        process.exit(1);
+      }
+
+      const userIds = opts.ids.split(',').map((id: string) => id.trim()).filter(Boolean);
+
+      info(`Bulk set presence for ${userIds.length} users (concurrency: ${opts.concurrency}, dry-run: ${!!opts.dryRun})`);
+
+      const result = await client.bulk.users({
+        userIds,
+        action: 'set_presence',
+        presence: opts.presence as 'auto' | 'away',
+        concurrency: parseInt(opts.concurrency, 10),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\rProgress: ${current}/${total}`);
+        },
+      });
+
+      console.log();
+      if (format === 'json') {
+        print(result, format);
+      } else {
+        info(`Done: ${result.success} succeeded, ${result.failed} failed out of ${result.total}`);
+        if (result.errors.length > 0) {
+          error('Failures:');
+          result.errors.forEach((e: { userId: string; error: string }) => {
+            console.error(`  - ${e.userId}: ${e.error}`);
+          });
+        }
+      }
+    } catch (e) {
+      error((e as Error).message);
+      process.exit(1);
+    }
+  });
+
 program.parse();