gdrivekit 1.0.3 → 1.0.4

package/README.md

@@ -58,7 +58,8 @@ 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, initDriveService } from "gdrivekit";
+import { operations } from "gdrivekit";
+import { initDriveService } from "./drivers/services";
 
 async function main() {
   initDriveService();
@@ -147,6 +148,14 @@ main();
 
 ---
 
+## Json Operation
+| Method                  | Description                               |
+| ----------------------- | ----------------------------------------- |
+| `readJsonFileData()`    | Read JSON file content                    |
+| `addJsonKeyValue()`     | Add a new key-value pair to a JSON file   |
+| `updateJsonFieldAndValues()`     | Update an existing field in a JSON file   |
+| `deleteJsonFieldAndKeys()`     | Delete a field from a JSON file           |
+
 ### ⚡ Example: Upload a File
 
 ```ts
@@ -170,6 +179,25 @@ if (files?.data?.files?.length) {
 
 ---
 
+### ⚡ Example: Add a Key-Value Pair to a JSON File
+
+```ts
+const fileId = "1234567890abcdef1234567890abcdef";
+const addResult = await operations.addJsonKeyValue(
+  fileId,
+  "alive",
+  true
+);
+
+if (addResult.success) {
+  console.log("✅ Added new key-value pair successfully");
+} else {
+  console.error("❌ Failed:", addResult.error);
+}
+```
+
+---
+
 ### 🧑‍💻 Author
 
 **Vikash Khati**

package/dist/index.js

@@ -778704,6 +778704,7 @@ var exports_operations = {};
 __export(exports_operations, {
   uploadMultipleFiles: () => uploadMultipleFiles,
   uploadFile: () => uploadFile,
+  updateJsonFieldAndValues: () => updateJsonFieldAndValues,
   updateFile: () => updateFile,
   searchStarredFiles: () => searchStarredFiles,
   searchSharedFiles: () => searchSharedFiles,
@@ -778713,6 +778714,8 @@ __export(exports_operations, {
   searchByExactName: () => searchByExactName,
   searchByContent: () => searchByContent,
   renameFile: () => renameFile,
+  readJsonFileData: () => readJsonFileData,
+  readFileData: () => readFileData,
   moveFileByName: () => moveFileByName,
   moveFile: () => moveFile,
   listRecentFiles: () => listRecentFiles,
@@ -778729,224 +778732,16 @@ __export(exports_operations, {
   downloadMultipleFiles: () => downloadMultipleFiles,
   downloadFile: () => downloadFile,
   deleteMultipleFiles: () => deleteMultipleFiles,
+  deleteJsonFieldAndKeys: () => deleteJsonFieldAndKeys,
   deleteFolder: () => deleteFolder,
   deleteFile: () => deleteFile,
   createFolder: () => createFolder,
-  copyFile: () => copyFile
+  copyFile: () => copyFile,
+  addJsonKeyValue: () => addJsonKeyValue
 });
 
-// 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 = {
@@ -778962,6 +778757,7 @@ var MIME_TYPES = {
   POWERPOINT: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
   TEXT: "text/plain",
   CSV: "text/csv",
+  JSON: "application/json",
   JPEG: "image/jpeg",
   PNG: "image/png",
   GIF: "image/gif",
@@ -778975,11 +778771,19 @@ var MIME_TYPES = {
 };
 
 // operations.ts
+async function readFileData(fileId) {
+  const response = await driveService.readFileData(fileId);
+  if (response.success && response.data) {
+    return typeof response.data === "string" ? response.data : response.data.toString();
+  }
+  throw new Error(response.error || "Failed to read file data");
+}
 async function uploadFile(filePath, options) {
   return await driveService.uploadFile(filePath, {
     name: options?.fileName,
     parents: options?.folderId ? [options.folderId] : undefined,
-    description: options?.description
+    description: options?.description,
+    mimeType: options?.mimeType
   });
 }
 async function downloadFile(fileId, savePath) {
@@ -779002,7 +778806,9 @@ async function moveFile(fileId, newFolderId) {
   if (!file.success || !file.data) {
     return { success: false, error: "File not found" };
   }
-  return await driveService.updateFileMetadata(fileId, { parents: [newFolderId] });
+  return await driveService.updateFileMetadata(fileId, {
+    parents: [newFolderId]
+  });
 }
 async function moveFileByName(fileName, folderName) {
   const fileResult = await getFileIdByName(fileName);
@@ -779018,6 +778824,130 @@ async function moveFileByName(fileName, folderName) {
 async function copyFile(fileId, newName) {
   return await driveService.copyFile(fileId, newName ? { name: newName } : undefined);
 }
+async function readJsonFileData(fileId) {
+  const content = await readFileData(fileId);
+  try {
+    return { success: true, data: JSON.parse(content) };
+  } catch (error) {
+    return { success: false, error: "Failed to parse JSON file content" };
+  }
+}
+async function addJsonKeyValue(fileId, key, value) {
+  try {
+    const readResponse = await driveService.readFileData(fileId, true);
+    if (!readResponse.success || !readResponse.data) {
+      throw new Error(readResponse.error || "Failed to read JSON file data");
+    }
+    let jsonData;
+    try {
+      jsonData = JSON.parse(readResponse.data);
+    } catch {
+      throw new Error("Invalid JSON format in file");
+    }
+    const parts = key.split(".");
+    let current = jsonData;
+    for (let i2 = 0;i2 < parts.length - 1; i2++) {
+      const part = parts[i2];
+      if (!current[part] || typeof current[part] !== "object") {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    current[parts.at(-1)] = value;
+    const updateResponse = await driveService.updateJsonContent(fileId, jsonData);
+    if (!updateResponse.success) {
+      throw new Error(updateResponse.error || "Failed to update file");
+    }
+    return { success: true, data: updateResponse.data };
+  } catch (error) {
+    console.error("❌ Error adding key-value pair:", error.message);
+    return { success: false, error: error.message };
+  }
+}
+async function deleteJsonFieldAndKeys(fileId, key) {
+  try {
+    const readResponse = await driveService.readFileData(fileId, true);
+    if (!readResponse.success || !readResponse.data) {
+      throw new Error(readResponse.error || "Failed to read JSON file data");
+    }
+    let jsonData;
+    try {
+      jsonData = JSON.parse(readResponse.data);
+    } catch {
+      throw new Error("Invalid JSON format in file");
+    }
+    const parts = key.split(".");
+    let current = jsonData;
+    for (let i2 = 0;i2 < parts.length - 1; i2++) {
+      const part = parts[i2];
+      if (!current[part] || typeof current[part] !== "object") {
+        throw new Error(`Key path '${key}' does not exist in JSON`);
+      }
+      current = current[part];
+    }
+    const lastKey = parts.at(-1);
+    if (!(lastKey in current)) {
+      throw new Error(`Key '${lastKey}' does not exist`);
+    }
+    delete current[lastKey];
+    const updateResponse = await driveService.updateJsonContent(fileId, jsonData);
+    if (!updateResponse.success) {
+      throw new Error(updateResponse.error || "Failed to update file");
+    }
+    return { success: true, data: updateResponse.data };
+  } catch (error) {
+    console.error("❌ Error deleting key-value pair:", error.message);
+    return { success: false, error: error.message };
+  }
+}
+async function updateJsonFieldAndValues(fileId, keyPath, newKey, newValue) {
+  try {
+    const readResponse = await driveService.readFileData(fileId, true);
+    if (!readResponse.success || !readResponse.data) {
+      throw new Error(readResponse.error || "Failed to read JSON file data");
+    }
+    let jsonData;
+    try {
+      jsonData = JSON.parse(readResponse.data);
+    } catch {
+      throw new Error("Invalid JSON format in file");
+    }
+    const parts = keyPath.split(".");
+    let current = jsonData;
+    for (let i2 = 0;i2 < parts.length - 1; i2++) {
+      const part = parts[i2];
+      if (!current[part] || typeof current[part] !== "object") {
+        throw new Error(`Key path '${keyPath}' does not exist in JSON`);
+      }
+      current = current[part];
+    }
+    const oldKey = parts.at(-1);
+    if (!(oldKey in current)) {
+      throw new Error(`Key '${oldKey}' does not exist`);
+    }
+    const existingValue = current[oldKey];
+    const finalValue = newValue !== undefined ? newValue : existingValue;
+    const finalKey = newKey && newKey !== oldKey ? newKey : oldKey;
+    const rebuilt = {};
+    for (const k of Object.keys(current)) {
+      if (k === oldKey) {
+        rebuilt[finalKey] = finalValue;
+      } else {
+        rebuilt[k] = current[k];
+      }
+    }
+    Object.keys(current).forEach((k) => delete current[k]);
+    Object.assign(current, rebuilt);
+    const updateResponse = await driveService.updateJsonContent(fileId, jsonData);
+    if (!updateResponse.success) {
+      throw new Error(updateResponse.error || "Failed to update file");
+    }
+    return { success: true, data: updateResponse.data };
+  } catch (error) {
+    console.error("❌ Error updating JSON key-value:", error.message);
+    return { success: false, error: error.message };
+  }
+}
 async function createFolder(folderName, parentFolderId) {
   return await driveService.createFolder(folderName, parentFolderId);
 }
@@ -779159,6 +779089,7 @@ async function getFileIdByName(fileName) {
   return { success: false, error: "File not found" };
 }
 var driveOperations = {
+  readFileData,
   uploadFile,
   downloadFile,
   deleteFile,
@@ -779168,6 +779099,10 @@ var driveOperations = {
   moveFile,
   moveFileByName,
   copyFile,
+  readJsonFileData,
+  addJsonKeyValue,
+  updateJsonFieldAndValues,
+  deleteJsonFieldAndKeys,
   createFolder,
   deleteFolder,
   listAllFolders,
@@ -779192,8 +779127,8 @@ var driveOperations = {
 };
 
 // auth.ts
-var import_googleapis2 = __toESM(require_src8(), 1);
-import * as fs4 from "fs";
+var import_googleapis = __toESM(require_src8(), 1);
+import * as fs2 from "fs";
 import * as http3 from "http";
 import * as url from "url";
 var CREDENTIALS_PATH = "./credentials.json";
@@ -779205,7 +779140,7 @@ async function generateCredentialsAndTokens({
   redirecturis,
   javascript_origin
 }) {
-  if (!fs4.existsSync(CREDENTIALS_PATH)) {
+  if (!fs2.existsSync(CREDENTIALS_PATH)) {
     const baseCredentials = {
       web: {
         client_id: clientid,
@@ -779218,17 +779153,17 @@ async function generateCredentialsAndTokens({
         javascript_origins: javascript_origin || ["http://localhost:3000"]
       }
     };
-    fs4.writeFileSync(CREDENTIALS_PATH, JSON.stringify(baseCredentials, null, 2));
+    fs2.writeFileSync(CREDENTIALS_PATH, JSON.stringify(baseCredentials, null, 2));
     console.log("✅ Created credentials.json");
   }
-  const credentials = JSON.parse(fs4.readFileSync(CREDENTIALS_PATH, "utf-8"));
+  const credentials = JSON.parse(fs2.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_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"));
+  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"));
     oauth2Client.setCredentials(tokens);
     console.log("✅ Using existing tokens from tokens.json");
     return oauth2Client;
@@ -779257,7 +779192,7 @@ async function generateCredentialsAndTokens({
             throw new Error("No authorization code received");
           const { tokens } = await oauth2Client.getToken(code);
           oauth2Client.setCredentials(tokens);
-          fs4.writeFileSync(TOKENS_PATH, JSON.stringify(tokens, null, 2));
+          fs2.writeFileSync(TOKENS_PATH, JSON.stringify(tokens, null, 2));
           console.log("✅ Tokens saved to tokens.json");
           res.writeHead(200, { "Content-Type": "text/html" });
           res.end(`
@@ -779299,6 +779234,5 @@ async function generateCredentialsAndTokens({
 }
 export {
   exports_operations as operations,
-  initDriveService,
   generateCredentialsAndTokens
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdrivekit",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "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",