@churchapps/content-providers 0.8.0 → 0.9.0

package/dist/index.js

@@ -17703,6 +17703,150 @@ var GoCurriculumProvider = class extends BaseProvider {
   }
 };
 
+// src/providers/googledrive/GoogleDriveProvider.ts
+var FOLDER_MIME = "application/vnd.google-apps.folder";
+var MAX_PAGINATION_CALLS2 = 10;
+var LEAF_CHECK_MAX_FOLDERS = 50;
+var GoogleDriveProvider = class extends BaseProvider {
+  constructor() {
+    super(...arguments);
+    this.oauthHelper = new OAuthHelper();
+    this.id = "googledrive";
+    this.name = "Google Drive";
+    this.logos = {
+      light: "https://ssl.gstatic.com/images/branding/product/2x/drive_2020q4_48dp.png",
+      dark: "https://ssl.gstatic.com/images/branding/product/2x/drive_2020q4_48dp.png"
+    };
+    this.config = {
+      id: "googledrive",
+      name: "Google Drive",
+      apiBase: "https://www.googleapis.com/drive/v3",
+      // Token endpoint host; the user-facing consent screen is accounts.google.com (see buildAuthUrlFromChallenge)
+      oauthBase: "https://oauth2.googleapis.com",
+      // TODO owner action: Google Cloud OAuth web client id (drive.readonly scope) — fill before publishing
+      clientId: "",
+      // Google requires client_secret even for PKCE public clients; injected server-side via setProviderSecret("googledrive", ...)
+      get clientSecret() {
+        return getProviderSecret("googledrive");
+      },
+      scopes: ["https://www.googleapis.com/auth/drive.readonly"]
+    };
+    this.requiresAuth = true;
+    this.authTypes = ["oauth_pkce"];
+    this.capabilities = {
+      browse: true,
+      playlist: true,
+      instructions: true,
+      mediaLicensing: false
+    };
+  }
+  // Paths are Drive folder ids ("/<id>"), not names; root is "" or "/"
+  folderIdFromPath(path) {
+    const trimmed = (path || "").replace(/^\//, "");
+    return trimmed || "root";
+  }
+  isValidId(id) {
+    return /^[\w-]+$/.test(id);
+  }
+  async listFiles(query, auth) {
+    if (!auth) {
+      console.error("[GoogleDrive] No auth token provided");
+      return [];
+    }
+    const all = [];
+    let pageToken;
+    for (let i = 0; i < MAX_PAGINATION_CALLS2; i++) {
+      const params = new URLSearchParams({
+        q: query,
+        fields: "nextPageToken,files(id,name,mimeType,thumbnailLink,webContentLink,parents)",
+        orderBy: "folder,name_natural",
+        pageSize: "1000",
+        supportsAllDrives: "true",
+        includeItemsFromAllDrives: "true"
+      });
+      if (pageToken) params.set("pageToken", pageToken);
+      const response = await this.apiRequest(`/files?${params.toString()}`, auth);
+      if (!response) break;
+      all.push(...response.files || []);
+      pageToken = response.nextPageToken;
+      if (!pageToken) break;
+    }
+    return all;
+  }
+  async childItems(folderId, auth) {
+    const entries = await this.listFiles(`'${folderId}' in parents and trashed=false`, auth);
+    const folders = entries.filter((e) => e.mimeType === FOLDER_MIME);
+    const mediaFiles = entries.filter((e) => e.mimeType.startsWith("video/") || e.mimeType.startsWith("image/"));
+    return { folders, mediaFiles };
+  }
+  /** One batched query marks which sibling folders have subfolders; null = unknown (isLeaf omitted). */
+  async leafIds(folders, auth) {
+    if (folders.length === 0 || folders.length > LEAF_CHECK_MAX_FOLDERS) return null;
+    const parentClause = folders.map((f) => `'${f.id}' in parents`).join(" or ");
+    const subfolders = await this.listFiles(`mimeType='${FOLDER_MIME}' and trashed=false and (${parentClause})`, auth);
+    const parentsWithSubfolders = new Set(subfolders.flatMap((s) => s.parents || []));
+    return new Set(folders.filter((f) => !parentsWithSubfolders.has(f.id)).map((f) => f.id));
+  }
+  toContentFile(file) {
+    const url = file.webContentLink || `https://drive.google.com/uc?id=${file.id}&export=download`;
+    return {
+      type: "file",
+      id: file.id,
+      title: file.name,
+      mediaType: detectMediaType(file.name, file.mimeType),
+      thumbnail: file.thumbnailLink,
+      url,
+      downloadUrl: url
+    };
+  }
+  async browse(path, auth) {
+    const folderId = this.folderIdFromPath(path);
+    if (!this.isValidId(folderId)) return [];
+    const { folders, mediaFiles } = await this.childItems(folderId, auth);
+    const leaves = await this.leafIds(folders, auth);
+    const folderItems = folders.map((f) => ({ type: "folder", id: f.id, title: f.name, path: `/${f.id}`, isLeaf: leaves ? leaves.has(f.id) : void 0 }));
+    return [...folderItems, ...mediaFiles.map((f) => this.toContentFile(f))];
+  }
+  async getPlaylist(path, auth, _resolution) {
+    const folderId = this.folderIdFromPath(path);
+    if (folderId === "root" || !this.isValidId(folderId)) return null;
+    const { mediaFiles } = await this.childItems(folderId, auth);
+    return mediaFiles.length > 0 ? mediaFiles.map((f) => this.toContentFile(f)) : null;
+  }
+  async getInstructions(path, auth) {
+    const files = await this.getPlaylist(path, auth);
+    if (!files) return null;
+    const meta = await this.apiRequest(`/files/${this.folderIdFromPath(path)}?fields=name&supportsAllDrives=true`, auth);
+    const folderName = meta?.name || "Google Drive";
+    return filesToInstructions(folderName, files, { id: "googledrive-section", label: folderName });
+  }
+  generateCodeVerifier() {
+    return this.oauthHelper.generateCodeVerifier();
+  }
+  async buildAuthUrl(codeVerifier, redirectUri, state) {
+    const codeChallenge = await this.oauthHelper.generateCodeChallenge(codeVerifier);
+    return { url: this.buildAuthUrlFromChallenge(codeChallenge, redirectUri, state || this.id), challengeMethod: "S256" };
+  }
+  buildAuthUrlFromChallenge(codeChallenge, redirectUri, state) {
+    const params = new URLSearchParams({
+      response_type: "code",
+      client_id: this.config.clientId,
+      redirect_uri: redirectUri,
+      scope: this.config.scopes.join(" "),
+      code_challenge: codeChallenge,
+      code_challenge_method: "S256",
+      // offline + consent so Google issues a refresh_token on every connect
+      access_type: "offline",
+      prompt: "consent",
+      state
+    });
+    return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+  }
+  async exchangeCodeForTokens(code, codeVerifier, redirectUri) {
+    return this.oauthHelper.exchangeCodeForTokens(this.config, this.id, code, codeVerifier, redirectUri);
+  }
+};
+
 // src/providers/index.ts
 var unimplementedProviders = [
   {
@@ -17744,6 +17888,7 @@ function initializeProviders() {
     new B1ChurchProvider(),
     new DropboxProvider(),
     new GoCurriculumProvider(),
+    new GoogleDriveProvider(),
     new BibleProjectProvider(),
     new HighVoltageKidsProvider(),
     new JesusFilmProvider(),
@@ -17788,7 +17933,7 @@ function getAvailableProviders(ids) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.8.0" : "dev";
+var VERSION = true ? "0.9.0" : "dev";
 export {
   APlayProvider,
   B1ChurchProvider,