@remcostoeten/fync/dist-cjs/src/google-drive/index.js

Unified TypeScript library for 9 popular APIs with consistent functional architecture

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var _exportNames = {
  GoogleDrive: true
};
exports.GoogleDrive = GoogleDrive;
var _core = require("../core");
var _types = require("./types");
Object.keys(_types).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _types[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _types[key];
    }
  });
});
const GOOGLE_DRIVE_API_BASE = "https://www.googleapis.com/drive/v3";
const filesResource = (0, _core.defineResource)({
  name: "files",
  basePath: "/files",
  methods: {
    listFiles: {
      path: ""
    },
    getFile: {
      path: "/{fileId}"
    },
    createFile: {
      path: "",
      method: "POST"
    },
    updateFile: {
      path: "/{fileId}",
      method: "PATCH"
    },
    deleteFile: {
      path: "/{fileId}",
      method: "DELETE"
    },
    copyFile: {
      path: "/{fileId}/copy",
      method: "POST"
    },
    moveFile: {
      path: "/{fileId}",
      method: "PATCH"
    },
    exportFile: {
      path: "/{fileId}/export"
    },
    downloadFile: {
      path: "/{fileId}"
    },
    generateIds: {
      path: "/generateIds"
    },
    watchFile: {
      path: "/{fileId}/watch",
      method: "POST"
    },
    emptyTrash: {
      path: "/trash",
      method: "DELETE"
    },
    getFileMetadata: {
      path: "/{fileId}"
    },
    updateFileMetadata: {
      path: "/{fileId}",
      method: "PATCH"
    }
  }
});
const permissionsResource = (0, _core.defineResource)({
  name: "permissions",
  basePath: "/files/{fileId}/permissions",
  methods: {
    listPermissions: {
      path: ""
    },
    getPermission: {
      path: "/{permissionId}"
    },
    createPermission: {
      path: "",
      method: "POST"
    },
    updatePermission: {
      path: "/{permissionId}",
      method: "PATCH"
    },
    deletePermission: {
      path: "/{permissionId}",
      method: "DELETE"
    }
  }
});
const commentsResource = (0, _core.defineResource)({
  name: "comments",
  basePath: "/files/{fileId}/comments",
  methods: {
    listComments: {
      path: ""
    },
    getComment: {
      path: "/{commentId}"
    },
    createComment: {
      path: "",
      method: "POST"
    },
    updateComment: {
      path: "/{commentId}",
      method: "PATCH"
    },
    deleteComment: {
      path: "/{commentId}",
      method: "DELETE"
    }
  }
});
const repliesResource = (0, _core.defineResource)({
  name: "replies",
  basePath: "/files/{fileId}/comments/{commentId}/replies",
  methods: {
    listReplies: {
      path: ""
    },
    getReply: {
      path: "/{replyId}"
    },
    createReply: {
      path: "",
      method: "POST"
    },
    updateReply: {
      path: "/{replyId}",
      method: "PATCH"
    },
    deleteReply: {
      path: "/{replyId}",
      method: "DELETE"
    }
  }
});
const revisionsResource = (0, _core.defineResource)({
  name: "revisions",
  basePath: "/files/{fileId}/revisions",
  methods: {
    listRevisions: {
      path: ""
    },
    getRevision: {
      path: "/{revisionId}"
    },
    updateRevision: {
      path: "/{revisionId}",
      method: "PATCH"
    },
    deleteRevision: {
      path: "/{revisionId}",
      method: "DELETE"
    }
  }
});
const drivesResource = (0, _core.defineResource)({
  name: "drives",
  basePath: "/drives",
  methods: {
    listDrives: {
      path: ""
    },
    getDrive: {
      path: "/{driveId}"
    },
    createDrive: {
      path: "",
      method: "POST"
    },
    updateDrive: {
      path: "/{driveId}",
      method: "PATCH"
    },
    deleteDrive: {
      path: "/{driveId}",
      method: "DELETE"
    },
    hideDrive: {
      path: "/{driveId}/hide",
      method: "POST"
    },
    unhideDrive: {
      path: "/{driveId}/unhide",
      method: "POST"
    }
  }
});
const changesResource = (0, _core.defineResource)({
  name: "changes",
  basePath: "/changes",
  methods: {
    listChanges: {
      path: ""
    },
    getStartPageToken: {
      path: "/startPageToken"
    },
    watchChanges: {
      path: "/watch",
      method: "POST"
    }
  }
});
const channelsResource = (0, _core.defineResource)({
  name: "channels",
  basePath: "/channels",
  methods: {
    stopChannel: {
      path: "/stop",
      method: "POST"
    }
  }
});
const aboutResource = (0, _core.defineResource)({
  name: "about",
  basePath: "/about",
  methods: {
    getAbout: {
      path: ""
    }
  }
});
const resources = {
  files: filesResource,
  permissions: permissionsResource,
  comments: commentsResource,
  replies: repliesResource,
  revisions: revisionsResource,
  drives: drivesResource,
  changes: changesResource,
  channels: channelsResource,
  about: aboutResource
};
const buildGoogleDrive = (0, _core.createApiBuilder)({
  baseUrl: GOOGLE_DRIVE_API_BASE,
  auth: {
    type: "bearer"
  },
  headers: {
    "Content-Type": "application/json"
  }
});
function GoogleDrive(config) {
  const base = buildGoogleDrive(config, resources);
  const drive = base;
  drive.listFiles = function (options) {
    return base.files.listFiles(options);
  };
  drive.getFile = function (fileId) {
    return base.files.getFile({
      fileId
    });
  };
  drive.createFile = function (metadata, content) {
    const body = content ? {
      ...metadata,
      media: content
    } : metadata;
    return base.files.createFile(body);
  };
  drive.updateFile = function (fileId, metadata, content) {
    const body = content ? {
      ...metadata,
      media: content
    } : metadata;
    return base.files.updateFile({
      fileId,
      ...body
    });
  };
  drive.deleteFile = function (fileId) {
    return base.files.deleteFile({
      fileId
    });
  };
  drive.copyFile = function (fileId, name) {
    const body = name ? {
      name
    } : {};
    return base.files.copyFile({
      fileId,
      ...body
    });
  };
  drive.moveFile = function (fileId, parentId) {
    return base.files.updateFile({
      fileId,
      addParents: parentId,
      removeParents: "root"
    });
  };
  drive.downloadFile = function (fileId) {
    return base.files.downloadFile({
      fileId,
      alt: "media"
    });
  };
  drive.exportFile = function (fileId, mimeType) {
    return base.files.exportFile({
      fileId,
      mimeType
    });
  };
  drive.createFolder = function (name, parentId) {
    const metadata = {
      name,
      mimeType: "application/vnd.google-apps.folder",
      parents: parentId ? [parentId] : ["root"]
    };
    return base.files.createFile(metadata);
  };
  drive.listFolders = async function () {
    const response = await base.files.listFiles({
      q: "mimeType='application/vnd.google-apps.folder'",
      fields: "files(id, name, parents, createdTime, modifiedTime)"
    });
    return response.files || [];
  };
  drive.getFolderContents = async function (folderId) {
    const response = await base.files.listFiles({
      q: `'${folderId}' in parents`,
      fields: "files(id, name, mimeType, size, createdTime, modifiedTime)"
    });
    return response.files || [];
  };
  drive.searchFiles = async function (query) {
    const response = await base.files.listFiles({
      q: `name contains '${query}'`,
      fields: "files(id, name, mimeType, size, createdTime, modifiedTime)"
    });
    return response.files || [];
  };
  drive.getFilesByName = async function (name) {
    const response = await base.files.listFiles({
      q: `name = '${name}'`,
      fields: "files(id, name, mimeType, size, createdTime, modifiedTime)"
    });
    return response.files || [];
  };
  drive.getFilesByType = async function (mimeType) {
    const response = await base.files.listFiles({
      q: `mimeType = '${mimeType}'`,
      fields: "files(id, name, size, createdTime, modifiedTime)"
    });
    return response.files || [];
  };
  drive.getSharedFiles = async function () {
    const response = await base.files.listFiles({
      q: "sharedWithMe = true",
      fields: "files(id, name, mimeType, size, owners, sharingUser)"
    });
    return response.files || [];
  };
  drive.getRecentFiles = async function (days = 7) {
    const date = new Date();
    date.setDate(date.getDate() - days);
    const dateString = date.toISOString();
    const response = await base.files.listFiles({
      q: `modifiedTime > '${dateString}'`,
      orderBy: "modifiedTime desc",
      fields: "files(id, name, mimeType, size, modifiedTime)"
    });
    return response.files || [];
  };
  drive.getStorageQuota = async function () {
    const response = await base.about.getAbout({
      fields: "storageQuota, user"
    });
    return {
      used: response.storageQuota?.usage || 0,
      limit: response.storageQuota?.limit || 0,
      usageInDrive: response.storageQuota?.usageInDrive || 0,
      usageInDriveTrash: response.storageQuota?.usageInDriveTrash || 0
    };
  };
  drive.shareFile = function (fileId, email, role = "reader") {
    return base.permissions.createPermission({
      type: "user",
      role,
      emailAddress: email
    }, {
      fileId
    });
  };
  drive.unshareFile = function (fileId, permissionId) {
    return base.permissions.deletePermission({
      fileId,
      permissionId
    });
  };
  drive.getFilePermissions = function (fileId) {
    return base.permissions.listPermissions({
      fileId
    });
  };
  drive.emptyTrash = function () {
    return base.files.emptyTrash();
  };
  drive.restoreFile = function (fileId) {
    return base.files.updateFile({
      fileId,
      trashed: false
    });
  };
  drive.permanentlyDeleteFile = function (fileId) {
    return base.files.deleteFile({
      fileId,
      supportsAllDrives: true
    });
  };
  return drive;
}