@hasna/connectors 1.3.22 → 1.3.23

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

@@ -0,0 +1,219 @@
+import type { LinearClient } 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;
+}
+
+// --- Issue Bulk Operations ---
+
+export interface BulkIssueOptions extends BulkOperationOptions {
+  issueIds: string[];
+  /** Action to perform */
+  action: 'archive' | 'change_state' | 'assign' | 'set_priority' | 'add_to_project';
+  /** State ID (for change_state) */
+  stateId?: string;
+  /** User ID (for assign) */
+  assigneeId?: string;
+  /** Priority 0-4 (for set_priority) */
+  priority?: number;
+  /** Project ID (for add_to_project) */
+  projectId?: string;
+}
+
+export interface BulkIssueResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ issueId: string; error: string }>;
+  results: Array<{ issueId: string; response: unknown }>;
+}
+
+// --- Label Bulk Operations ---
+
+export interface BulkLabelOptions extends BulkOperationOptions {
+  /** Issues to apply/remove label from */
+  issueIds: string[];
+  /** Label ID to add or remove */
+  labelId: string;
+  /** Action: add or remove label */
+  action: 'add' | 'remove';
+}
+
+export interface BulkLabelResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ issueId: string; error: string }>;
+  results: Array<{ issueId: string; response: unknown }>;
+}
+
+// ============================================
+// Bulk Operations API
+// ============================================
+
+export class BulkApi {
+  private readonly client: LinearClient;
+
+  constructor(client: LinearClient) {
+    this.client = client;
+  }
+
+  // ============================================
+  // Bulk Issue Operations
+  // ============================================
+
+  async issues(options: BulkIssueOptions): Promise<BulkIssueResult> {
+    const { issueIds, action, concurrency = 10, dryRun = false, onProgress, onError, stateId, assigneeId, priority, projectId } = options;
+
+    const result: BulkIssueResult = {
+      total: issueIds.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (issueIds.length === 0) return result;
+
+    const chunks = this.chunkArray(issueIds, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (issueId) => {
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              let response: unknown;
+              if (action === 'archive') {
+                response = await this.archiveIssue(issueId);
+              } else if (action === 'change_state') {
+                if (!stateId) throw new Error('stateId is required for change_state');
+                response = await this.updateIssue(issueId, { stateId });
+              } else if (action === 'assign') {
+                if (!assigneeId) throw new Error('assigneeId is required for assign');
+                response = await this.updateIssue(issueId, { assigneeId });
+              } else if (action === 'set_priority') {
+                if (priority === undefined) throw new Error('priority is required for set_priority');
+                response = await this.updateIssue(issueId, { priority });
+              } else if (action === 'add_to_project') {
+                if (!projectId) throw new Error('projectId is required for add_to_project');
+                response = await this.updateIssue(issueId, { projectId });
+              }
+              result.success++;
+              result.results.push({ issueId, response });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, issueId);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ issueId, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), issueId);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Bulk Label Operations
+  // ============================================
+
+  async labels(options: BulkLabelOptions): Promise<BulkLabelResult> {
+    const { issueIds, labelId, action, concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkLabelResult = {
+      total: issueIds.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (issueIds.length === 0) return result;
+
+    const chunks = this.chunkArray(issueIds, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (issueId) => {
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              // Linear doesn't have a direct add/remove label mutation,
+              // so we update the issue's labelIds
+              const response = await this.updateIssue(issueId, {
+                labelIds: action === 'add' ? [labelId] : undefined,
+              });
+              result.success++;
+              result.results.push({ issueId, response });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, issueId);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ issueId, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), issueId);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Private Helpers
+  // ============================================
+
+  private async updateIssue(id: string, input: Record<string, unknown>): Promise<unknown> {
+    const mutation = `
+      mutation IssueUpdate($id: String!, $input: IssueUpdateInput!) {
+        issueUpdate(id: $id, input: $input) {
+          success
+          issue {
+            id
+            identifier
+            title
+          }
+        }
+      }
+    `;
+    return this.client.mutate(mutation, { id, input });
+  }
+
+  private async archiveIssue(id: string): Promise<unknown> {
+    const mutation = `
+      mutation IssueArchive($id: String!) {
+        issueArchive(id: $id) {
+          success
+        }
+      }
+    `;
+    return this.client.mutate(mutation, { id });
+  }
+
+  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-linear/src/api/index.ts

@@ -6,6 +6,7 @@ import { TeamsApi } from './teams';
 import { UsersApi } from './users';
 import { CommentsApi } from './comments';
 import { StatesApi } from './states';
+import { BulkApi } from './bulk';
 
 export { LinearClient } from './client';
 export { IssuesApi } from './issues';
@@ -14,6 +15,7 @@ export { TeamsApi } from './teams';
 export { UsersApi } from './users';
 export { CommentsApi } from './comments';
 export { StatesApi } from './states';
+export { BulkApi } from './bulk';
 
 /**
  * Main Linear API class
@@ -27,6 +29,7 @@ export class Linear {
   public readonly users: UsersApi;
   public readonly comments: CommentsApi;
   public readonly states: StatesApi;
+  public readonly bulk: BulkApi;
 
   constructor(config: LinearConfig) {
     this.client = new LinearClient(config);
@@ -36,6 +39,7 @@ export class Linear {
     this.users = new UsersApi(this.client);
     this.comments = new CommentsApi(this.client);
     this.states = new StatesApi(this.client);
+    this.bulk = new BulkApi(this.client);
   }
 
   /**

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

@@ -557,4 +557,120 @@ usersCmd
     }
   });
 
+// ============================================
+// Bulk Operations
+// ============================================
+
+const bulkCmd = program
+  .command('bulk')
+  .description('Bulk operations');
+
+bulkCmd
+  .command('issues')
+  .description('Bulk issue operations')
+  .option('--ids <ids>', 'Comma-separated issue IDs')
+  .option('--action <action>', 'Action: archive/change_state/assign/set_priority/add_to_project')
+  .option('--state-id <id>', 'Target state ID (for change_state)')
+  .option('--assignee-id <id>', 'Target user ID (for assign)')
+  .option('--priority <n>', 'Priority 0-4 (for set_priority)')
+  .option('--project-id <id>', 'Target project ID (for add_to_project)')
+  .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 || !opts.action) {
+        error('--ids and --action are required');
+        process.exit(1);
+      }
+
+      const issueIds = opts.ids.split(',').map((id: string) => id.trim()).filter(Boolean);
+
+      info(`Bulk ${opts.action} on ${issueIds.length} issues (concurrency: ${opts.concurrency}, dry-run: ${!!opts.dryRun})`);
+
+      const result = await client.bulk.issues({
+        issueIds,
+        action: opts.action,
+        stateId: opts.stateId,
+        assigneeId: opts.assigneeId,
+        priority: opts.priority ? parseInt(opts.priority, 10) : undefined,
+        projectId: opts.projectId,
+        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: { issueId: string; error: string }) => {
+            console.error(`  - ${e.issueId}: ${e.error}`);
+          });
+        }
+      }
+    } catch (e) {
+      error((e as Error).message);
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('labels')
+  .description('Bulk add/remove labels from issues')
+  .option('--issue-ids <ids>', 'Comma-separated issue IDs')
+  .option('--label-id <id>', 'Label ID to add or remove')
+  .option('--action <action>', 'Action: add or remove')
+  .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.issueIds || !opts.labelId || !opts.action) {
+        error('--issue-ids, --label-id, and --action are required');
+        process.exit(1);
+      }
+
+      const issueIds = opts.issueIds.split(',').map((id: string) => id.trim()).filter(Boolean);
+
+      info(`Bulk ${opts.action} label ${opts.labelId} to ${issueIds.length} issues (concurrency: ${opts.concurrency}, dry-run: ${!!opts.dryRun})`);
+
+      const result = await client.bulk.labels({
+        issueIds,
+        labelId: opts.labelId,
+        action: opts.action as 'add' | 'remove',
+        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: { issueId: string; error: string }) => {
+            console.error(`  - ${e.issueId}: ${e.error}`);
+          });
+        }
+      }
+    } catch (e) {
+      error((e as Error).message);
+      process.exit(1);
+    }
+  });
+
 program.parse();

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

@@ -0,0 +1,288 @@
+import type { ShopifyClient } 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;
+}
+
+// --- Product Bulk Operations ---
+
+export interface BulkProductOptions extends BulkOperationOptions {
+  productIds: number[];
+  /** Action to perform */
+  action: 'delete' | 'activate' | 'archive';
+}
+
+export interface BulkProductResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ productId: number; error: string }>;
+  results: Array<{ productId: number; response: unknown }>;
+}
+
+// --- Order Bulk Operations ---
+
+export interface BulkOrderOptions extends BulkOperationOptions {
+  orderIds: number[];
+  /** Action to perform */
+  action: 'close' | 'open' | 'cancel';
+  /** Cancel reason (for cancel action only) */
+  cancelReason?: 'customer' | 'inventory' | 'fraud' | 'declined' | 'other';
+  /** Send cancel email notification */
+  cancelEmail?: boolean;
+  /** Restock items on cancel */
+  cancelRestock?: boolean;
+}
+
+export interface BulkOrderResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ orderId: number; error: string }>;
+  results: Array<{ orderId: number; response: unknown }>;
+}
+
+// --- Inventory Bulk Operations ---
+
+export interface BulkInventoryOptions extends BulkOperationOptions {
+  /** Items with their target levels per location */
+  items: Array<{ inventoryItemId: number; locationId: number; available: number }>;
+  /** Action: set to exact value, or adjust by amount */
+  action: 'set' | 'adjust';
+}
+
+export interface BulkInventoryResult {
+  total: number;
+  success: number;
+  failed: number;
+  errors: Array<{ inventoryItemId: number; locationId: number; error: string }>;
+  results: Array<{ inventoryItemId: number; locationId: number; response: unknown }>;
+}
+
+// ============================================
+// Bulk Operations API
+// ============================================
+
+export class BulkApi {
+  private readonly client: ShopifyClient;
+
+  constructor(client: ShopifyClient) {
+    this.client = client;
+  }
+
+  // ============================================
+  // Bulk Product Operations
+  // ============================================
+
+  async products(options: BulkProductOptions): Promise<BulkProductResult> {
+    const { productIds, action, concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkProductResult = {
+      total: productIds.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (productIds.length === 0) return result;
+
+    const chunks = this.chunkArray(productIds, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (productId) => {
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              let response: unknown;
+              if (action === 'delete') {
+                await this.client.request<void>(`/products/${productId}.json`, { method: 'DELETE' });
+                response = { deleted: productId };
+              } else {
+                response = await this.client.request<{ product: Record<string, unknown> }>(
+                  `/products/${productId}.json`,
+                  {
+                    method: 'PUT',
+                    body: { product: { id: productId, status: action === 'activate' ? 'active' : 'archived' } },
+                  }
+                );
+              }
+              result.success++;
+              result.results.push({ productId, response });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, productId);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ productId, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), productId);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Bulk Order Operations
+  // ============================================
+
+  async orders(options: BulkOrderOptions): Promise<BulkOrderResult> {
+    const { orderIds, action, cancelReason, cancelEmail, cancelRestock, concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkOrderResult = {
+      total: orderIds.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (orderIds.length === 0) return result;
+
+    const chunks = this.chunkArray(orderIds, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (orderId) => {
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              let response: unknown;
+              if (action === 'close') {
+                response = await this.client.request<{ order: Record<string, unknown> }>(
+                  `/orders/${orderId}/close.json`,
+                  { method: 'POST' }
+                );
+              } else if (action === 'open') {
+                response = await this.client.request<{ order: Record<string, unknown> }>(
+                  `/orders/${orderId}/open.json`,
+                  { method: 'POST' }
+                );
+              } else {
+                const body: Record<string, unknown> = {};
+                if (cancelReason) body.reason = cancelReason;
+                if (cancelEmail !== undefined) body.email = cancelEmail;
+                if (cancelRestock !== undefined) body.restock = cancelRestock;
+                response = await this.client.request<{ order: Record<string, unknown> }>(
+                  `/orders/${orderId}/cancel.json`,
+                  { method: 'POST', body: Object.keys(body).length > 0 ? body : undefined }
+                );
+              }
+              result.success++;
+              result.results.push({ orderId, response });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, orderId);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ orderId, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), orderId);
+          }
+        })
+      );
+    }
+
+    return result;
+  }
+
+  // ============================================
+  // Bulk Inventory Operations
+  // ============================================
+
+  async inventory(options: BulkInventoryOptions): Promise<BulkInventoryResult> {
+    const { items, action, concurrency = 10, dryRun = false, onProgress, onError } = options;
+
+    const result: BulkInventoryResult = {
+      total: items.length,
+      success: 0,
+      failed: 0,
+      errors: [],
+      results: [],
+    };
+
+    if (items.length === 0) return result;
+
+    const chunks = this.chunkArray(items, concurrency);
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (item) => {
+          const { inventoryItemId, locationId, available } = item;
+          try {
+            if (dryRun) {
+              result.success++;
+            } else {
+              let response: unknown;
+              if (action === 'set') {
+                response = await this.client.request<{ inventory_level: Record<string, unknown> }>(
+                  '/inventory_levels/set.json',
+                  {
+                    method: 'POST',
+                    body: {
+                      location_id: locationId,
+                      inventory_item_id: inventoryItemId,
+                      available,
+                    },
+                  }
+                );
+              } else {
+                response = await this.client.request<{ inventory_level: Record<string, unknown> }>(
+                  '/inventory_levels/adjust.json',
+                  {
+                    method: 'POST',
+                    body: {
+                      location_id: locationId,
+                      inventory_item_id: inventoryItemId,
+                      available_adjustment: available,
+                    },
+                  }
+                );
+              }
+              result.success++;
+              result.results.push({ inventoryItemId, locationId, response });
+            }
+
+            if (onProgress) onProgress(result.success + result.failed, result.total, item);
+          } catch (err) {
+            result.failed++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            result.errors.push({ inventoryItemId, locationId, error: errorMessage });
+            if (onError) onError(err instanceof Error ? err : new Error(errorMessage), item);
+          }
+        })
+      );
+    }
+
+    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-shopify/src/api/index.ts

@@ -6,6 +6,7 @@ import { CustomersApi } from './customers';
 import { InventoryApi } from './inventory';
 import { CollectionsApi } from './collections';
 import { ShopApi } from './shop';
+import { BulkApi } from './bulk';
 
 /**
  * Main Shopify Connector class
@@ -21,6 +22,7 @@ export class Shopify {
   public readonly inventory: InventoryApi;
   public readonly collections: CollectionsApi;
   public readonly shop: ShopApi;
+  public readonly bulk: BulkApi;
 
   constructor(config: ShopifyConfig) {
     this.client = new ShopifyClient(config);
@@ -30,6 +32,7 @@ export class Shopify {
     this.inventory = new InventoryApi(this.client);
     this.collections = new CollectionsApi(this.client);
     this.shop = new ShopApi(this.client);
+    this.bulk = new BulkApi(this.client);
   }
 
   /**
@@ -87,3 +90,4 @@ export { CustomersApi } from './customers';
 export { InventoryApi } from './inventory';
 export { CollectionsApi } from './collections';
 export { ShopApi } from './shop';
+export { BulkApi } from './bulk';