gdrivekit 1.0.2 → 1.0.3

package/README.md

@@ -58,8 +58,7 @@ After that, you **don’t need to call it again** unless you delete your tokens
 Once tokens are generated, you can initialize the Google Drive service and perform file operations:
 
 ```ts
-import { operations } from "gdrivekit";
-import { initDriveService } from "./drivers/services";
+import { operations, initDriveService } from "gdrivekit";
 
 async function main() {
   initDriveService();

package/dist/index.js

@@ -778735,8 +778735,218 @@ __export(exports_operations, {
   copyFile: () => copyFile
 });
 
+// drivers/services.ts
+import fs3 from "fs";
+
+// drivers/GoogleDriveService.ts
+var import_googleapis = __toESM(require_src8(), 1);
+import * as fs2 from "fs";
+import * as path from "path";
+
+class GoogleDriveService {
+  oauth2Client;
+  drive;
+  constructor(credentials) {
+    const creds = credentials.web || credentials.installed || credentials;
+    const { client_id, client_secret } = creds;
+    const redirect_uri = "redirect_uris" in creds ? creds.redirect_uris[0] : credentials.redirect_uri;
+    this.oauth2Client = new import_googleapis.google.auth.OAuth2(client_id, client_secret, redirect_uri);
+    this.drive = import_googleapis.google.drive({ version: "v3", auth: this.oauth2Client });
+  }
+  setCredentials(tokens) {
+    this.oauth2Client.setCredentials(tokens);
+    this.oauth2Client.on("tokens", (newTokens) => {
+      if (newTokens.refresh_token) {
+        tokens.refresh_token = newTokens.refresh_token;
+      }
+      tokens.access_token = newTokens.access_token;
+      tokens.expiry_date = newTokens.expiry_date;
+      fs2.writeFileSync("./tokens.json", JSON.stringify(tokens, null, 2));
+      console.log("\uD83D\uDD04 Tokens refreshed and saved");
+    });
+  }
+  async listFiles(params = {}) {
+    try {
+      const response = await this.drive.files.list({
+        pageSize: params.pageSize || 10,
+        fields: "nextPageToken, files(id, name, mimeType, size, createdTime, modifiedTime)",
+        q: params.query || undefined,
+        orderBy: params.orderBy || "modifiedTime desc",
+        pageToken: params.pageToken || undefined
+      });
+      return {
+        success: true,
+        data: {
+          files: response.data.files,
+          nextPageToken: response.data.nextPageToken || undefined
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async getFileMetadata(fileId) {
+    try {
+      const response = await this.drive.files.get({
+        fileId,
+        fields: "id, name, mimeType, size, createdTime, modifiedTime, parents, webViewLink"
+      });
+      return {
+        success: true,
+        data: response.data
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async downloadFile(fileId, destPath) {
+    try {
+      const dest = fs2.createWriteStream(destPath);
+      const response = await this.drive.files.get({ fileId, alt: "media" }, { responseType: "stream" });
+      return new Promise((resolve, reject) => {
+        response.data.on("end", () => {
+          resolve({ success: true, data: { path: destPath } });
+        }).on("error", (err) => {
+          reject({ success: false, error: err.message });
+        }).pipe(dest);
+      });
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async uploadFile(filePath, metadata = {}) {
+    try {
+      const fileMetadata = {
+        name: metadata.name || path.basename(filePath),
+        parents: metadata.parents || []
+      };
+      const media = {
+        mimeType: metadata.mimeType,
+        body: fs2.createReadStream(filePath)
+      };
+      const response = await this.drive.files.create({
+        requestBody: fileMetadata,
+        media,
+        fields: "id, name, mimeType, size, webViewLink"
+      });
+      return {
+        success: true,
+        data: response.data
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async updateFileContent(fileId, filePath) {
+    try {
+      const media = {
+        body: fs2.createReadStream(filePath)
+      };
+      const response = await this.drive.files.update({
+        fileId,
+        media,
+        fields: "id, name, mimeType, modifiedTime"
+      });
+      return {
+        success: true,
+        data: response.data
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async updateFileMetadata(fileId, metadata) {
+    try {
+      const response = await this.drive.files.update({
+        fileId,
+        requestBody: metadata,
+        fields: "id, name, mimeType, modifiedTime"
+      });
+      return {
+        success: true,
+        data: response.data
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async deleteFile(fileId) {
+    try {
+      await this.drive.files.delete({
+        fileId
+      });
+      return {
+        success: true,
+        data: { message: "File deleted successfully" }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async createFolder(folderName, parentFolderId) {
+    try {
+      const fileMetadata = {
+        name: folderName,
+        mimeType: "application/vnd.google-apps.folder"
+      };
+      if (parentFolderId) {
+        fileMetadata.parents = [parentFolderId];
+      }
+      const response = await this.drive.files.create({
+        requestBody: fileMetadata,
+        fields: "id, name, mimeType"
+      });
+      return {
+        success: true,
+        data: response.data
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async searchFiles(searchQuery, pageSize = 10) {
+    return this.listFiles({
+      query: searchQuery,
+      pageSize
+    });
+  }
+}
+
 // drivers/services.ts
 var driveService;
+async function initDriveService(creds, tokens) {
+  if (!driveService) {
+    const credentials = creds ?? JSON.parse(fs3.readFileSync("./credentials.json", "utf-8"));
+    driveService = new GoogleDriveService(credentials);
+    const tokenData = tokens ?? JSON.parse(fs3.readFileSync("./tokens.json", "utf-8"));
+    driveService.setCredentials(tokenData);
+  }
+  return driveService;
+}
 
 // types/index.ts
 var MIME_TYPES = {
@@ -778982,8 +779192,8 @@ var driveOperations = {
 };
 
 // auth.ts
-var import_googleapis = __toESM(require_src8(), 1);
-import * as fs2 from "fs";
+var import_googleapis2 = __toESM(require_src8(), 1);
+import * as fs4 from "fs";
 import * as http3 from "http";
 import * as url from "url";
 var CREDENTIALS_PATH = "./credentials.json";
@@ -778995,7 +779205,7 @@ async function generateCredentialsAndTokens({
   redirecturis,
   javascript_origin
 }) {
-  if (!fs2.existsSync(CREDENTIALS_PATH)) {
+  if (!fs4.existsSync(CREDENTIALS_PATH)) {
     const baseCredentials = {
       web: {
         client_id: clientid,
@@ -779008,17 +779218,17 @@ async function generateCredentialsAndTokens({
         javascript_origins: javascript_origin || ["http://localhost:3000"]
       }
     };
-    fs2.writeFileSync(CREDENTIALS_PATH, JSON.stringify(baseCredentials, null, 2));
+    fs4.writeFileSync(CREDENTIALS_PATH, JSON.stringify(baseCredentials, null, 2));
     console.log("✅ Created credentials.json");
   }
-  const credentials = JSON.parse(fs2.readFileSync(CREDENTIALS_PATH, "utf-8"));
+  const credentials = JSON.parse(fs4.readFileSync(CREDENTIALS_PATH, "utf-8"));
   const creds = credentials.web || credentials.installed || credentials;
   const client_id = creds.client_id;
   const client_secret = creds.client_secret;
   const redirect_uri = Array.isArray(creds.redirect_uris) ? creds.redirect_uris[0] : creds.redirect_uri;
-  const oauth2Client = new import_googleapis.google.auth.OAuth2(client_id, client_secret, redirect_uri);
-  if (fs2.existsSync(TOKENS_PATH)) {
-    const tokens = JSON.parse(fs2.readFileSync(TOKENS_PATH, "utf-8"));
+  const oauth2Client = new import_googleapis2.google.auth.OAuth2(client_id, client_secret, redirect_uri);
+  if (fs4.existsSync(TOKENS_PATH)) {
+    const tokens = JSON.parse(fs4.readFileSync(TOKENS_PATH, "utf-8"));
     oauth2Client.setCredentials(tokens);
     console.log("✅ Using existing tokens from tokens.json");
     return oauth2Client;
@@ -779047,7 +779257,7 @@ async function generateCredentialsAndTokens({
             throw new Error("No authorization code received");
           const { tokens } = await oauth2Client.getToken(code);
           oauth2Client.setCredentials(tokens);
-          fs2.writeFileSync(TOKENS_PATH, JSON.stringify(tokens, null, 2));
+          fs4.writeFileSync(TOKENS_PATH, JSON.stringify(tokens, null, 2));
           console.log("✅ Tokens saved to tokens.json");
           res.writeHead(200, { "Content-Type": "text/html" });
           res.end(`
@@ -779089,5 +779299,6 @@ async function generateCredentialsAndTokens({
 }
 export {
   exports_operations as operations,
+  initDriveService,
   generateCredentialsAndTokens
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdrivekit",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A lightweight Google Drive toolkit for File Management. Handle Google Drive operations easily — upload, download, and other file operations in a few lines of code.",
   "type": "module",
   "main": "dist/index.js",