@hasna/connectors 1.3.22 → 1.3.23

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

@@ -816,5 +816,527 @@ eventCmd
     }
   });
 
+// ============================================
+// Bulk Commands
+// ============================================
+const bulkCmd = program
+  .command('bulk')
+  .description('Bulk operations on events');
+
+bulkCmd
+  .command('preview')
+  .description('Preview events matching a query')
+  .option('-c, --calendar <id>', 'Calendar ID', 'primary')
+  .option('-q, --query <text>', 'Search query')
+  .option('--time-min <date>', 'Start date (RFC3339)')
+  .option('--time-max <date>', 'End date (RFC3339)')
+  .option('-n, --max <number>', 'Maximum events to preview', '20')
+  .action(async (opts) => {
+    try {
+      const client = await getClient();
+      const label = opts.query ? `matching: ${opts.query}` : `on calendar: ${opts.calendar}`;
+      info(`Previewing events ${label}`);
+
+      const result = await client.bulk.preview(opts.calendar, {
+        query: opts.query,
+        timeMin: opts.timeMin,
+        timeMax: opts.timeMax,
+        maxResults: parseInt(opts.max),
+      });
+
+      if (result.events.length === 0) {
+        info('No events found');
+        return;
+      }
+
+      success(`Found ${result.total} event(s):`);
+      const output = result.events.map(e => ({
+        id: e.id,
+        summary: e.summary,
+        start: e.start,
+        end: e.end,
+        status: e.status,
+        location: e.location || '-',
+      }));
+      print(output, getFormat(bulkCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('delete')
+  .description('Delete events matching a query (DANGER!)')
+  .option('-c, --calendar <id>', 'Calendar ID', 'primary')
+  .option('-q, --query <text>', 'Search query')
+  .option('--time-min <date>', 'Start date (RFC3339)')
+  .option('--time-max <date>', 'End date (RFC3339)')
+  .option('-n, --max <number>', 'Maximum events to process', '100')
+  .option('-k, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .option('--confirm', 'Confirm permanent deletion')
+  .action(async (opts) => {
+    try {
+      if (!opts.dryRun && !opts.confirm) {
+        error('Permanent deletion requires --confirm flag');
+        info('Use --dry-run to preview what would be deleted');
+        process.exit(1);
+      }
+
+      const client = await getClient();
+      warn(`${opts.dryRun ? '[DRY RUN] ' : ''}PERMANENTLY DELETING events on ${opts.calendar}`);
+      if (opts.query) info(`  Query: ${opts.query}`);
+      if (opts.timeMin) info(`  From: ${opts.timeMin}`);
+      if (opts.timeMax) info(`  To: ${opts.timeMax}`);
+
+      const result = await client.bulk.delete({
+        calendarId: opts.calendar,
+        query: opts.query,
+        timeMin: opts.timeMin,
+        timeMax: opts.timeMax,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk delete complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('create')
+  .description('Create multiple events from a JSON file')
+  .option('-c, --calendar <id>', 'Calendar ID', 'primary')
+  .option('-f, --file <path>', 'Path to JSON file with events array')
+  .option('-k, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview without creating')
+  .option('--notify', 'Send notifications to attendees')
+  .action(async (opts) => {
+    try {
+      const { readFileSync } = await import('fs');
+
+      if (!opts.file) {
+        error('--file is required');
+        process.exit(1);
+      }
+
+      const events = JSON.parse(readFileSync(opts.file, 'utf-8'));
+      if (!Array.isArray(events)) {
+        error('JSON file must contain an array of events');
+        process.exit(1);
+      }
+
+      const client = await getClient();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Creating ${events.length} event(s) on ${opts.calendar}`);
+
+      const result = await client.bulk.create({
+        calendarId: opts.calendar,
+        events,
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        sendNotifications: opts.notify === true,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk create complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('update')
+  .description('Update events matching a query with partial data')
+  .option('-c, --calendar <id>', 'Calendar ID', 'primary')
+  .option('-q, --query <text>', 'Search query')
+  .option('--time-min <date>', 'Start date (RFC3339)')
+  .option('--time-max <date>', 'End date (RFC3339)')
+  .option('-n, --max <number>', 'Maximum events to process', '100')
+  .option('-k, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .option('--updates <json>', 'JSON object with fields to update (e.g. \'{"location":"Remote"}\')')
+  .action(async (opts) => {
+    try {
+      if (!opts.updates) {
+        error('--updates is required (JSON object)');
+        process.exit(1);
+      }
+
+      const updates = JSON.parse(opts.updates);
+      const client = await getClient();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Updating events on ${opts.calendar}`);
+      if (opts.query) info(`  Query: ${opts.query}`);
+      info(`  Updates: ${JSON.stringify(updates)}`);
+
+      const result = await client.bulk.update({
+        calendarId: opts.calendar,
+        query: opts.query,
+        timeMin: opts.timeMin,
+        timeMax: opts.timeMax,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        updates,
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk update complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('accept')
+  .description('Accept event invitations matching a query')
+  .option('-c, --calendar <id>', 'Calendar ID', 'primary')
+  .option('-q, --query <text>', 'Search query')
+  .option('--time-min <date>', 'Start date (RFC3339)')
+  .option('--time-max <date>', 'End date (RFC3339)')
+  .option('-n, --max <number>', 'Maximum events to process', '100')
+  .option('-k, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .option('--comment <text>', 'Optional comment')
+  .action(async (opts) => {
+    try {
+      const client = await getClient();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Accepting events on ${opts.calendar}`);
+      if (opts.query) info(`  Query: ${opts.query}`);
+
+      const result = await client.bulk.accept({
+        calendarId: opts.calendar,
+        query: opts.query,
+        timeMin: opts.timeMin,
+        timeMax: opts.timeMax,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        comment: opts.comment,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk accept complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('decline')
+  .description('Decline event invitations matching a query')
+  .option('-c, --calendar <id>', 'Calendar ID', 'primary')
+  .option('-q, --query <text>', 'Search query')
+  .option('--time-min <date>', 'Start date (RFC3339)')
+  .option('--time-max <date>', 'End date (RFC3339)')
+  .option('-n, --max <number>', 'Maximum events to process', '100')
+  .option('-k, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .option('--comment <text>', 'Optional comment')
+  .action(async (opts) => {
+    try {
+      const client = await getClient();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Declining events on ${opts.calendar}`);
+      if (opts.query) info(`  Query: ${opts.query}`);
+
+      const result = await client.bulk.decline({
+        calendarId: opts.calendar,
+        query: opts.query,
+        timeMin: opts.timeMin,
+        timeMax: opts.timeMax,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        comment: opts.comment,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk decline complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('tentative')
+  .description('Mark events as tentative matching a query')
+  .option('-c, --calendar <id>', 'Calendar ID', 'primary')
+  .option('-q, --query <text>', 'Search query')
+  .option('--time-min <date>', 'Start date (RFC3339)')
+  .option('--time-max <date>', 'End date (RFC3339)')
+  .option('-n, --max <number>', 'Maximum events to process', '100')
+  .option('-k, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .option('--comment <text>', 'Optional comment')
+  .action(async (opts) => {
+    try {
+      const client = await getClient();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Marking events as tentative on ${opts.calendar}`);
+      if (opts.query) info(`  Query: ${opts.query}`);
+
+      const result = await client.bulk.tentative({
+        calendarId: opts.calendar,
+        query: opts.query,
+        timeMin: opts.timeMin,
+        timeMax: opts.timeMax,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        comment: opts.comment,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk tentative complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Free/Busy Commands
+// ============================================
+const freebusyCmd = program
+  .command('freebusy')
+  .description('Query free/busy information');
+
+freebusyCmd
+  .command('query')
+  .description('Query free/busy for one or more calendars')
+  .requiredOption('-c, --calendar <ids>', 'Comma-separated calendar IDs')
+  .requiredOption('--time-min <date>', 'Start time (RFC3339)')
+  .requiredOption('--time-max <date>', 'End time (RFC3339)')
+  .option('--timezone <tz>', 'Timezone')
+  .action(async (opts) => {
+    try {
+      const client = await getClient();
+      const calendarIds = opts.calendar.split(',').map((s: string) => s.trim());
+
+      const result = await client.freebusy.query({
+        timeMin: opts.timeMin,
+        timeMax: opts.timeMax,
+        items: calendarIds.map((id: string) => ({ id })),
+        timeZone: opts.timezone,
+      });
+
+      const format = getFormat(freebusyCmd);
+      if (format === 'json') {
+        print(result, format);
+      } else {
+        for (const [calId, calInfo] of Object.entries(result.calendars)) {
+          console.log(chalk.bold(`  ${calId}`));
+          if (calInfo.busy.length === 0) {
+            info('    Free');
+          } else {
+            for (const slot of calInfo.busy) {
+              const start = new Date(slot.start).toLocaleString();
+              const end = new Date(slot.end).toLocaleString();
+              console.log(`    ${chalk.yellow('Busy:')} ${start} → ${end}`);
+            }
+          }
+          if (calInfo.errors && calInfo.errors.length > 0) {
+            for (const e of calInfo.errors) {
+              warn(`    Error: ${e.message}`);
+            }
+          }
+        }
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+freebusyCmd
+  .command('check')
+  .description('Quick check if a calendar is free during a time range')
+  .requiredOption('-c, --calendar <id>', 'Calendar ID')
+  .requiredOption('--time-min <date>', 'Start time (RFC3339)')
+  .requiredOption('--time-max <date>', 'End time (RFC3339)')
+  .action(async (opts) => {
+    try {
+      const client = await getClient();
+      const free = await client.freebusy.isFree(opts.calendar, opts.timeMin, opts.timeMax);
+
+      const format = getFormat(freebusyCmd);
+      if (format === 'json') {
+        print({ calendar: opts.calendar, free, timeMin: opts.timeMin, timeMax: opts.timeMax }, format);
+      } else {
+        if (free) {
+          success(`${opts.calendar} is free from ${new Date(opts.timeMin).toLocaleString()} to ${new Date(opts.timeMax).toLocaleString()}`);
+        } else {
+          warn(`${opts.calendar} is busy during ${new Date(opts.timeMin).toLocaleString()} to ${new Date(opts.timeMax).toLocaleString()}`);
+        }
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// ACL Commands
+// ============================================
+const aclCmd = program
+  .command('acl')
+  .description('Manage calendar access control lists');
+
+aclCmd
+  .command('list')
+  .description('List ACL rules for a calendar')
+  .requiredOption('-c, --calendar <id>', 'Calendar ID')
+  .action(async (opts) => {
+    try {
+      const client = await getClient();
+      const result = await client.acl.list(opts.calendar);
+
+      const format = getFormat(aclCmd);
+      if (format === 'json') {
+        print(result, format);
+      } else {
+        if (result.items.length === 0) {
+          info(`No ACL rules found for ${opts.calendar}`);
+          return;
+        }
+        success(`ACL rules for ${opts.calendar}:`);
+        for (const rule of result.items) {
+          const scopeStr = rule.scope.type === 'default'
+            ? 'default'
+            : `${rule.scope.type}:${rule.scope.value}`;
+          console.log(`  ${rule.role.padEnd(18)} ${scopeStr}`);
+        }
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+aclCmd
+  .command('add')
+  .description('Add an ACL rule to a calendar')
+  .requiredOption('-c, --calendar <id>', 'Calendar ID')
+  .requiredOption('-r, --role <role>', 'Role: freeBusyReader, reader, writer, owner')
+  .requiredOption('--scope-type <type>', 'Scope type: user, group, domain, default')
+  .option('--scope-value <value>', 'Scope value (email for user/group, domain for domain)')
+  .action(async (opts) => {
+    try {
+      const role = opts.role as 'freeBusyReader' | 'reader' | 'writer' | 'owner';
+      const validRoles = ['freeBusyReader', 'reader', 'writer', 'owner'];
+      if (!validRoles.includes(role)) {
+        error(`Invalid role: ${role}. Must be one of: ${validRoles.join(', ')}`);
+        process.exit(1);
+      }
+
+      const scopeType = opts.scopeType as 'user' | 'group' | 'domain' | 'default';
+      const validTypes = ['user', 'group', 'domain', 'default'];
+      if (!validTypes.includes(scopeType)) {
+        error(`Invalid scope type: ${scopeType}. Must be one of: ${validTypes.join(', ')}`);
+        process.exit(1);
+      }
+
+      if (scopeType !== 'default' && !opts.scopeValue) {
+        error('--scope-value is required for user/group/domain scope types');
+        process.exit(1);
+      }
+
+      const client = await getClient();
+      const rule = await client.acl.insert(opts.calendar, {
+        role,
+        scope: {
+          type: scopeType,
+          value: opts.scopeValue,
+        },
+      });
+
+      success(`ACL rule added:`);
+      info(`  Role: ${rule.role}`);
+      info(`  Scope: ${rule.scope.type}${rule.scope.value ? `:${rule.scope.value}` : ''}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+aclCmd
+  .command('remove')
+  .description('Remove an ACL rule from a calendar')
+  .requiredOption('-c, --calendar <id>', 'Calendar ID')
+  .requiredOption('-i, --rule-id <id>', 'ACL rule ID to remove')
+  .action(async (opts) => {
+    try {
+      const client = await getClient();
+      await client.acl.delete(opts.calendar, opts.ruleId);
+      success(`ACL rule "${opts.ruleId}" removed from ${opts.calendar}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+aclCmd
+  .command('share')
+  .description('Share a calendar with a user')
+  .requiredOption('-c, --calendar <id>', 'Calendar ID')
+  .requiredOption('--with <email>', 'Email address to share with')
+  .option('-r, --role <role>', 'Access level: reader (default), writer, freeBusyReader', 'reader')
+  .action(async (opts) => {
+    try {
+      const client = await getClient();
+      const rule = await client.acl.insert(opts.calendar, {
+        role: opts.role,
+        scope: { type: 'user', value: opts.with },
+      });
+      success(`Shared ${opts.calendar} with ${opts.with} as ${rule.role}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
 // Parse and execute
 program.parse();

package/connectors/connect-googlecalendar/src/types/index.ts

@@ -345,3 +345,93 @@ export class GoogleCalendarApiError extends Error {
     this.errors = errors;
   }
 }
+
+// ============================================
+// Free/Busy Types
+// ============================================
+
+export interface FreeBusyTimeRange {
+  start: string; // RFC3339
+  end: string;   // RFC3339
+}
+
+export interface FreeBusyGroup {
+  id: string;
+  members?: { id: string }[];
+}
+
+export interface FreeBusyCalendarRequest {
+  id: string;
+}
+
+export interface FreeBusyGroupRequest {
+  id: string;
+}
+
+export interface FreeBusyRequest {
+  timeMin?: string;       // RFC3339
+  timeMax?: string;       // RFC3339
+  items: (FreeBusyCalendarRequest | FreeBusyGroupRequest)[];
+  groupExpansionMax?: number;
+  timeZone?: string;
+}
+
+export interface FreeBusyBusyPeriod {
+  start: string;
+  end: string;
+}
+
+export interface FreeBusyCalendar {
+  busy: FreeBusyBusyPeriod[];
+  errors?: ApiErrorDetail[];
+}
+
+export interface FreeBusyCalendarResponse {
+  calendars: { [calendarId: string]: FreeBusyCalendar };
+  groups?: { [groupId: string]: FreeBusyGroup };
+  kind: 'calendar#freeBusy';
+  timeMax: string;
+  timeMin: string;
+}
+
+// ============================================
+// ACL Types
+// ============================================
+
+export type CalendarAclRole =
+  | 'none'
+  | 'freeBusyReader'
+  | 'reader'
+  | 'writer'
+  | 'owner';
+
+export type CalendarAclScopeType =
+  | 'default'
+  | 'user'
+  | 'group'
+  | 'domain';
+
+export interface CalendarAclScope {
+  type: CalendarAclScopeType;
+  value?: string; // email for user/group, domain for domain
+}
+
+export interface CalendarAcl {
+  kind: 'calendar#aclRule';
+  etag: string;
+  id: string;
+  role: CalendarAclRole;
+  scope: CalendarAclScope;
+}
+
+export interface CalendarAclListResponse {
+  kind: 'calendar#acl';
+  etag: string;
+  nextPageToken?: string;
+  items: CalendarAcl[];
+}
+
+export interface CalendarAclInsert {
+  role: CalendarAclRole;
+  scope: CalendarAclScope;
+}