@hasna/connectors 1.3.22 → 1.3.23

package/connectors/connect-googledrive/src/api/changes.ts

@@ -0,0 +1,139 @@
+import type { DriveClient } from './client.ts';
+import type { DriveFile } from '../types/index.ts';
+
+// ============================================
+// Changes API Types
+// ============================================
+
+export interface ListChangesOptions {
+  pageToken: string;
+  pageSize?: number;
+  spaces?: string;
+  includeRemoved?: boolean;
+  includeItemsFromAllDrives?: boolean;
+  restrictToMyDrive?: boolean;
+  driveId?: string;
+  supportsAllDrives?: boolean;
+}
+
+export interface ChangeRecord {
+  fileId: string;
+  type: 'file' | 'drive' | 'driveMember';
+  removed?: boolean;
+  file?: DriveFile;
+  drive?: {
+    id: string;
+    name: string;
+    kind: string;
+  };
+  driveMember?: {
+    kind: string;
+    displayName: string;
+    photoLink: string;
+  };
+}
+
+export interface ListChangesResponse {
+  kind: string;
+  nextPageToken: string;
+  newStartPageToken: string;
+  changes: ChangeRecord[];
+}
+
+export interface WatchChangesOptions {
+  topicName: string;
+  params?: Record<string, string>;
+  watchType?: string;
+  watchId?: string;
+  token?: string;
+  expiration?: string;
+}
+
+export interface WatchResponse {
+  kind: string;
+  id: string;
+  resourceId: string;
+  resourceUri: string;
+  expiration: string;
+}
+
+/**
+ * Changes API module - track changes to Drive files and shared drives
+ */
+export class ChangesApi {
+  constructor(private readonly client: DriveClient) {}
+
+  /**
+   * Get the starting page token for change tracking
+   */
+  async getStartPageToken(options: {
+    supportsAllDrives?: boolean;
+    driveId?: string;
+  } = {}): Promise<{ nextPageToken: string }> {
+    const params: Record<string, string | boolean | undefined> = {};
+    if (options.supportsAllDrives !== undefined) params.supportsAllDrives = options.supportsAllDrives;
+    if (options.driveId) params.driveId = options.driveId;
+
+    return this.client.get<{ nextPageToken: string }>('/changes/startPageToken', params);
+  }
+
+  /**
+   * List changes for a user
+   */
+  async list(options: ListChangesOptions): Promise<ListChangesResponse> {
+    const params: Record<string, string | number | boolean | undefined> = {
+      pageToken: options.pageToken,
+    };
+    if (options.pageSize) params.pageSize = options.pageSize;
+    if (options.spaces) params.spaces = options.spaces;
+    if (options.includeRemoved !== undefined) params.includeRemoved = options.includeRemoved;
+    if (options.includeItemsFromAllDrives !== undefined) params.includeItemsFromAllDrives = options.includeItemsFromAllDrives;
+    if (options.restrictToMyDrive !== undefined) params.restrictToMyDrive = options.restrictToMyDrive;
+    if (options.driveId) params.driveId = options.driveId;
+    if (options.supportsAllDrives !== undefined) params.supportsAllDrives = options.supportsAllDrives;
+
+    return this.client.get<ListChangesResponse>('/changes', params);
+  }
+
+  /**
+   * Iterate over all changes (handles pagination)
+   */
+  async *listAll(options: Omit<ListChangesOptions, 'pageToken'> & { startPageToken: string }): AsyncGenerator<ChangeRecord> {
+    let pageToken = options.startPageToken;
+    const baseOptions = { ...options };
+    // @ts-expect-error pageToken will be set
+    delete baseOptions.pageToken;
+    // @ts-expect-error startPageToken is not part of ListChangesOptions
+    delete baseOptions.startPageToken;
+
+    do {
+      const response = await this.list({ ...baseOptions, pageToken });
+      for (const record of response.changes || []) {
+        yield record;
+      }
+      if (response.nextPageToken) {
+        pageToken = response.nextPageToken;
+      } else {
+        break;
+      }
+    } while (true);
+  }
+
+  /**
+   * Subscribe to push notifications for changes
+   */
+  async watch(options: WatchChangesOptions): Promise<WatchResponse> {
+    const body: Record<string, unknown> = {
+      id: options.watchId,
+      type: options.watchType || 'web_hook',
+      token: options.token,
+      expiration: options.expiration,
+    };
+    if (options.topicName) {
+      body.type = 'web_hook';
+      body.params = { topicName: options.topicName, ...(options.params || {}) };
+    }
+
+    return this.client.post<WatchResponse>('/changes/watch', body as unknown as Record<string, unknown>);
+  }
+}

package/connectors/connect-googledrive/src/api/client.ts

@@ -213,4 +213,38 @@ export class DriveClient {
 
     return response.arrayBuffer();
   }
+
+  async downloadRevision(fileId: string, revisionId: string): Promise<ArrayBuffer> {
+    const accessToken = await getValidAccessToken();
+    const url = DRIVE_API_BASE + '/files/' + fileId + '/revisions/' + revisionId + '?alt=media&supportsAllDrives=true';
+
+    const response = await fetch(url, {
+      headers: {
+        'Authorization': 'Bearer ' + accessToken,
+      },
+    });
+
+    if (!response.ok) {
+      throw new DriveApiError('Download revision failed: ' + response.statusText, response.status);
+    }
+
+    return response.arrayBuffer();
+  }
+
+  async exportRevision(fileId: string, revisionId: string, mimeType: string): Promise<ArrayBuffer> {
+    const accessToken = await getValidAccessToken();
+    const url = DRIVE_API_BASE + '/files/' + fileId + '/revisions/' + revisionId + '/export?mimeType=' + encodeURIComponent(mimeType);
+
+    const response = await fetch(url, {
+      headers: {
+        'Authorization': 'Bearer ' + accessToken,
+      },
+    });
+
+    if (!response.ok) {
+      throw new DriveApiError('Export revision failed: ' + response.statusText, response.status);
+    }
+
+    return response.arrayBuffer();
+  }
 }

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

@@ -4,6 +4,9 @@ import { FoldersApi } from './folders.ts';
 import { TrashApi } from './trash.ts';
 import { StorageApi } from './storage.ts';
 import { DrivesApi } from './drives.ts';
+import { BulkApi } from './bulk.ts';
+import { ChangesApi } from './changes.ts';
+import { RevisionsApi } from './revisions.ts';
 
 export class Drive {
   private readonly client: DriveClient;
@@ -14,6 +17,9 @@ export class Drive {
   public readonly trash: TrashApi;
   public readonly storage: StorageApi;
   public readonly drives: DrivesApi;
+  public readonly bulk: BulkApi;
+  public readonly changes: ChangesApi;
+  public readonly revisions: RevisionsApi;
 
   constructor() {
     this.client = new DriveClient();
@@ -22,6 +28,9 @@ export class Drive {
     this.trash = new TrashApi(this.client);
     this.storage = new StorageApi(this.client);
     this.drives = new DrivesApi(this.client);
+    this.bulk = new BulkApi(this.client);
+    this.changes = new ChangesApi(this.client);
+    this.revisions = new RevisionsApi(this.client);
   }
 
   /**
@@ -45,3 +54,6 @@ export { FoldersApi } from './folders.ts';
 export { TrashApi } from './trash.ts';
 export { StorageApi } from './storage.ts';
 export { DrivesApi } from './drives.ts';
+export { BulkApi } from './bulk.ts';
+export { ChangesApi } from './changes.ts';
+export { RevisionsApi } from './revisions.ts';

package/connectors/connect-googledrive/src/api/revisions.ts

@@ -0,0 +1,132 @@
+import type { DriveClient } from './client.ts';
+
+// ============================================
+// Revisions API Types
+// ============================================
+
+export interface FileRevision {
+  id: string;
+  mimeType: string;
+  modifiedTime?: string;
+  keepForever?: boolean;
+  published?: boolean;
+  publishedOutsideDomain?: boolean;
+  publishAuto?: boolean;
+  publishedLink?: string;
+  lastModifyingUser?: {
+    displayName: string;
+    photoLink: string;
+    me: boolean;
+    permissionId: string;
+    emailAddress: string;
+  };
+  originalFilename?: string;
+  size?: string;
+  exportLinks?: Record<string, string>;
+  sha1Checksum?: string;
+  sha256Checksum?: string;
+  md5Checksum?: string;
+  contentHints?: {
+    thumbnail?: {
+      image: string;
+      mimeType: string;
+    };
+  };
+}
+
+export interface ListRevisionsResponse {
+  kind: string;
+  fileExportMimeType?: string;
+  revisions: FileRevision[];
+}
+
+export interface ListRevisionsOptions {
+  pageSize?: number;
+  pageToken?: string;
+  fields?: string;
+}
+
+export interface UpdateRevisionOptions {
+  keepForever?: boolean;
+  publishAuto?: boolean;
+  published?: boolean;
+  publishedOutsideDomain?: boolean;
+}
+
+/**
+ * Revisions API module - manage file revision history
+ */
+export class RevisionsApi {
+  constructor(private readonly client: DriveClient) {}
+
+  /**
+   * List revisions of a file
+   */
+  async list(fileId: string, options: ListRevisionsOptions = {}): Promise<ListRevisionsResponse> {
+    const params: Record<string, string | number | undefined> = {};
+    if (options.pageSize) params.pageSize = options.pageSize;
+    if (options.pageToken) params.pageToken = options.pageToken;
+    if (options.fields) params.fields = options.fields;
+
+    return this.client.get<ListRevisionsResponse>(`/files/${fileId}/revisions`, params);
+  }
+
+  /**
+   * Iterate over all revisions of a file (handles pagination)
+   */
+  async *listAll(fileId: string, options: Omit<ListRevisionsOptions, 'pageToken'> = {}): AsyncGenerator<FileRevision> {
+    let pageToken: string | undefined;
+    do {
+      const response = await this.list(fileId, { ...options, pageToken });
+      for (const revision of response.revisions || []) {
+        yield revision;
+      }
+      pageToken = response.revisions?.length && response.revisions.length > 0
+        ? undefined
+        : undefined;
+      // Drive revisions API doesn't always paginate, so we check once
+      break;
+    } while (pageToken);
+  }
+
+  /**
+   * Get a specific revision
+   */
+  async get(fileId: string, revisionId: string): Promise<FileRevision> {
+    return this.client.get<FileRevision>(`/files/${fileId}/revisions/${revisionId}`);
+  }
+
+  /**
+   * Update revision metadata
+   */
+  async update(fileId: string, revisionId: string, options: UpdateRevisionOptions): Promise<FileRevision> {
+    const body: Record<string, unknown> = {};
+    if (options.keepForever !== undefined) body.keepForever = options.keepForever;
+    if (options.publishAuto !== undefined) body.publishAuto = options.publishAuto;
+    if (options.published !== undefined) body.published = options.published;
+    if (options.publishedOutsideDomain !== undefined) body.publishedOutsideDomain = options.publishedOutsideDomain;
+
+    return this.client.patch<FileRevision>(`/files/${fileId}/revisions/${revisionId}`, body);
+  }
+
+  /**
+   * Delete a revision
+   */
+  async delete(fileId: string, revisionId: string): Promise<void> {
+    await this.client.delete(`/files/${fileId}/revisions/${revisionId}`);
+  }
+
+  /**
+   * Download the content of a revision
+   */
+  async download(fileId: string, revisionId: string): Promise<ArrayBuffer> {
+    return this.client.downloadRevision(fileId, revisionId);
+  }
+
+  /**
+   * Export a Google Workspace document revision in a specific format
+   */
+  async export(fileId: string, revisionId: string, mimeType: string): Promise<ArrayBuffer> {
+    return this.client.exportRevision(fileId, revisionId, mimeType);
+  }
+}