@arela/uploader 1.0.19 → 1.0.21

package/src/services/GoogleDriveService.js

@@ -0,0 +1,217 @@
+import fs from 'fs';
+import { google } from 'googleapis';
+
+import appConfig from '../config/config.js';
+import PathNormalizer from '../utils/PathNormalizer.js';
+import logger from './LoggingService.js';
+
+const NATIVE_DOC_PREFIX = 'application/vnd.google-apps.';
+const FOLDER_MIME = 'application/vnd.google-apps.folder';
+const SHORTCUT_MIME = 'application/vnd.google-apps.shortcut';
+
+const DEFAULT_FILE_FIELDS =
+  'id,name,mimeType,modifiedTime,size,md5Checksum,parents,trashed,shortcutDetails';
+
+/**
+ * Google Drive Service
+ * Thin wrapper around googleapis Drive v3 with Service Account auth.
+ * Read-only by design (scope: drive.readonly).
+ */
+export class GoogleDriveService {
+  constructor() {
+    this.config = appConfig.getGDriveConfig();
+    this.drive = null;
+    this.commonParams = {
+      supportsAllDrives: true,
+      includeItemsFromAllDrives: true,
+    };
+  }
+
+  /**
+   * Lazy-init Drive v3 client.
+   * @returns {import('googleapis').drive_v3.Drive}
+   */
+  async getClient() {
+    if (this.drive) return this.drive;
+
+    let credentials = null;
+    let keyFile = null;
+
+    if (this.config.serviceAccountJson) {
+      try {
+        credentials = JSON.parse(this.config.serviceAccountJson);
+      } catch (err) {
+        throw new Error(
+          `GDRIVE_SERVICE_ACCOUNT_JSON is not valid JSON: ${err.message}`,
+        );
+      }
+    } else if (this.config.serviceAccountFile) {
+      keyFile = PathNormalizer.toAbsolutePath(this.config.serviceAccountFile);
+      if (!fs.existsSync(keyFile)) {
+        throw new Error(`Service account file not found: ${keyFile}`);
+      }
+    } else {
+      throw new Error(
+        'No Google Drive credentials configured (GDRIVE_SERVICE_ACCOUNT_FILE or GDRIVE_SERVICE_ACCOUNT_JSON)',
+      );
+    }
+
+    const auth = new google.auth.GoogleAuth({
+      credentials,
+      keyFile,
+      scopes: ['https://www.googleapis.com/auth/drive.readonly'],
+    });
+
+    this.drive = google.drive({ version: 'v3', auth });
+    return this.drive;
+  }
+
+  /**
+   * Get metadata for a single file/folder.
+   */
+  async getFile(fileId, fields = DEFAULT_FILE_FIELDS) {
+    const drive = await this.getClient();
+    const res = await drive.files.get({
+      fileId,
+      fields,
+      ...this.commonParams,
+    });
+    return res.data;
+  }
+
+  /**
+   * List direct children of a folder, paginated.
+   * Yields each child file metadata one at a time.
+   * @param {string} folderId
+   * @param {Object} [options]
+   * @param {string} [options.fields]
+   * @param {number} [options.pageSize]
+   * @returns {AsyncGenerator<Object>}
+   */
+  async *listChildren(folderId, options = {}) {
+    const drive = await this.getClient();
+    const fields = options.fields || DEFAULT_FILE_FIELDS;
+    const pageSize = options.pageSize || this.config.pageSize || 1000;
+
+    let pageToken = undefined;
+
+    do {
+      const res = await this.#withRetry(() =>
+        drive.files.list({
+          q: `'${folderId}' in parents and trashed = false`,
+          fields: `nextPageToken, files(${fields})`,
+          pageSize,
+          pageToken,
+          orderBy: 'folder,name',
+          ...this.commonParams,
+        }),
+      );
+
+      const files = res.data.files || [];
+      for (const file of files) {
+        yield file;
+      }
+      pageToken = res.data.nextPageToken;
+    } while (pageToken);
+  }
+
+  /**
+   * Download a file's binary content to a writable stream.
+   * Returns total bytes written.
+   * @param {string} fileId
+   * @param {import('stream').Writable} destStream
+   * @returns {Promise<number>}
+   */
+  async downloadFile(fileId, destStream) {
+    const drive = await this.getClient();
+
+    const res = await this.#withRetry(() =>
+      drive.files.get(
+        {
+          fileId,
+          alt: 'media',
+          ...this.commonParams,
+        },
+        { responseType: 'stream' },
+      ),
+    );
+
+    return await new Promise((resolve, reject) => {
+      let bytes = 0;
+      res.data.on('data', (chunk) => {
+        bytes += chunk.length;
+      });
+      res.data.on('error', reject);
+      destStream.on('error', reject);
+      destStream.on('finish', () => resolve(bytes));
+      res.data.pipe(destStream);
+    });
+  }
+
+  /**
+   * Static helpers
+   */
+  static isFolder(file) {
+    return file?.mimeType === FOLDER_MIME;
+  }
+
+  static isShortcut(file) {
+    return file?.mimeType === SHORTCUT_MIME;
+  }
+
+  static isNativeGoogleDoc(file) {
+    return (
+      typeof file?.mimeType === 'string' &&
+      file.mimeType.startsWith(NATIVE_DOC_PREFIX) &&
+      !GoogleDriveService.isFolder(file) &&
+      !GoogleDriveService.isShortcut(file)
+    );
+  }
+
+  /**
+   * Retry wrapper with exponential backoff for transient errors.
+   * @private
+   */
+  async #withRetry(fn, maxAttempts = 5) {
+    let attempt = 0;
+    let lastErr;
+
+    while (attempt < maxAttempts) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastErr = err;
+        const status = err?.code || err?.response?.status;
+        const reason =
+          err?.errors?.[0]?.reason ||
+          err?.response?.data?.error?.errors?.[0]?.reason;
+
+        const retryable =
+          status === 429 ||
+          status === 500 ||
+          status === 502 ||
+          status === 503 ||
+          status === 504 ||
+          reason === 'rateLimitExceeded' ||
+          reason === 'userRateLimitExceeded' ||
+          reason === 'backendError';
+
+        if (!retryable || attempt === maxAttempts - 1) {
+          throw err;
+        }
+
+        const delayMs =
+          Math.min(60_000, 2 ** attempt * 1000) + Math.random() * 500;
+        logger.warn(
+          `⚠️  Drive API ${status || ''} ${reason || ''} — retry ${attempt + 1}/${maxAttempts} in ${Math.round(delayMs)}ms`,
+        );
+        await new Promise((r) => setTimeout(r, delayMs));
+        attempt += 1;
+      }
+    }
+
+    throw lastErr;
+  }
+}
+
+export default GoogleDriveService;

package/src/services/LoggingService.js

@@ -46,7 +46,7 @@ export class LoggingService {
     });
     process.on('unhandledRejection', (reason, promise) => {
       this.error(`Unhandled Rejection at: ${promise}, reason: ${reason}`);
-      flushAndExit(1);
+      // Don't kill the process — allow it to continue processing remaining files
     });
   }