Pricing
Pay per usage
Moved to https://apify.com/onidivo/google-drive --------- ----- ---------- --------- ------- ------------ Manage Google Drive's files and folders. Mostly used for transferring files from Key-Value stores to Google Drive.
0.0 (0)
Pricing
Pay per usage
1
21
1
Last modified
5 years ago
{ "extends": "@apify"}apify_storagenode_modules.idea# This file tells Git which files shouldn't be added to source control
.ideanode_modules# Dockerfile contains instructions how to build a Docker image that will contain# all the code and configuration needed to run your actor. For a full# Dockerfile reference, see https://docs.docker.com/engine/reference/builder/
# First, specify the base Docker image. Apify provides the following base images# for your convenience:# apify/actor-node-basic (Node.js 10 on Alpine Linux, small and fast image)# apify/actor-node-chrome (Node.js 10 + Chrome on Debian)# apify/actor-node-chrome-xvfb (Node.js 10 + Chrome + Xvfb on Debian)# For more information, see https://apify.com/docs/actor#base-images# Note that you can use any other image from Docker Hub.FROM apify/actor-node-chrome
# Second, copy just package.json and package-lock.json since they are the only files# that affect NPM install in the next stepCOPY package*.json ./
# Install NPM packages, skip optional and development dependencies to keep the# image small. Avoid logging too much and print the dependency tree for debuggingRUN npm --quiet set progress=false \ && npm install --only=prod --no-optional \ && echo "Installed NPM packages:" \ && npm list \ && echo "Node.js version:" \ && node --version \ && echo "NPM version:" \ && npm --version
# Next, copy the remaining files and directories with the source code.# Since we do this after NPM install, quick build will be really fast# for simple source file changes.COPY . ./
# Specify how to run the source codeCMD npm start{ "name": "google-drive", "version": "0.0", "buildTag": "latest", "env": { "GOOGLE_APIS_CLIENT_SECRET": "@googleDriveGoogleApisClientSecret" }, "template": "puppeteer_single_page"}{ "name": "actor-google-drive", "version": "0.0.1", "description": "This is a boilerplate of an Apify actor.", "dependencies": { "apify": "^0.15.2", "apify-google-auth": "^0.3.0", "googleapis": "^43.0.0", "type-check": "^0.3.2" }, "devDependencies": { "@apify/eslint-config": "0.0.3", "apify-cli": "^0.5.2", "apify-shared": "^0.2.6", "eslint": "^6.4.0" }, "scripts": { "start": "node src/main.js", "apify:debug": "APIFY_LOG_LEVEL=DEBUG apify run", "apify:debug:purge": "APIFY_LOG_LEVEL=DEBUG apify run -p", "test:apify-platform:prepare": "node test/apify-platform/prepare.js" }, "author": "It's not you it's me", "license": "ISC"}1const { GOOGLE_APIS } = require('./consts');2const { validateAndParseInput } = require('./utils');3
4module.exports = class Config {5 constructor(input) {6 const { isSetupMode, operations, timeoutSecs } = validateAndParseInput(input);7 this.isSetupMode = isSetupMode;8 this.operations = operations;9 this.timeoutSecs = timeoutSecs;10
11 this.tokensStore = input.tokensStore || 'google-auth-tokens';12
13 this.googleApisCredentials = {14 client_id: GOOGLE_APIS.CLIENT_ID,15 client_secret: process.env.GOOGLE_APIS_CLIENT_SECRET,16 redirect_uri: GOOGLE_APIS.REDIRECT_URI,17 };18 }19};1const { apifyGoogleAuth } = require('apify-google-auth');2const { google } = require('googleapis');3const { OPERATIONS_TYPES } = require('./consts');4const { UploadOperation, DeleteFolderOperation } = require('./operations/index');5const { Folder } = require('./operations/helper');6
7const DRIVE_ERROR_MESSAGES = {8 insufficientPermissions: 'The user does not have sufficient permissions for this file',9};10class Service {11 /**12 * @param {Config} config13 */14 constructor(config) {15 this.config = config;16 }17
18 async init() {19 console.log('Initializing drive service...');20
21 const { tokensStore, googleApisCredentials } = this.config;22
23 this._auth = await apifyGoogleAuth({24 scope: 'drive',25 tokensStore,26 credentials: googleApisCredentials,27 });28 /**29 * drive api endpoint.30 * @type {v3.Drive}31 * @private32 */33 this._drive = google.drive({ version: 'v3', auth: this._auth });34 }35
36
37 /**38 * Lists files.39 */40 async listFiles(params = {}) {41 const defaults = {42 preListLogMsgFunction: ({ page, enableLog = false }) => enableLog && console.log(`Getting files (page ${page})...`),43 afterListLogMsgFunction: ({ files, enableLog = false }) => enableLog && console.log(`We found ${files.length} files`),44 };45 const {46 extraQ,47 pageSize = 1000,48 token = '',49 fields = 'nextPageToken, files(*)',50 root = false,51 trashed = false,52 spaces = 'drive',53 enableLog = false,54 filesList = [],55 page = 1,56 preListLogMsgFunction = defaults.preListLogMsgFunction,57 afterListLogMsgFunction = defaults.afterListLogMsgFunction,58 } = params;59
60 preListLogMsgFunction({ page, enableLog });61
62 const q = this.buildQuery({63 root,64 trashed,65 extraQ,66 });67 const { data } = await this._drive.files.list(68 {69 q,70 spaces,71 pageToken: token,72 pageSize,73 fields,74 },75 );76 Array.prototype.push.apply(filesList, data.files);77 const files = data.nextPageToken78 ? await this.listFiles({79 extraQ,80 pageSize,81 token,82 fields,83 root,84 trashed,85 spaces,86 filesList,87 page: page + 1,88 })89 : filesList;90
91 if (filesList.length === data.files.length) {92 afterListLogMsgFunction({ files, enableLog });93 }94 return files;95 }96
97 createFile(params) {98 const {99 resource,100 media,101 fields = '*',102 } = params;103
104 return this._drive.files.create({105 resource,106 media,107 fields,108 });109 }110
111 updateFile(params) {112 const {113 fileId,114 media,115 fields = '*',116 } = params;117
118 return this._drive.files.update({119 fileId,120 media,121 fields,122 });123 }124
125 /**126 * Lists files without folders.127 */128 async listFilesWithoutFolders(params = {}) {129 let { extraQ = '' } = params;130 if (extraQ === '') extraQ = 'mimeType != \'application/vnd.google-apps.folder\'';131
132 if (!extraQ.includes('mimeType')) extraQ += ' and mimeType != \'application/vnd.google-apps.folder\'';133 return this.listFiles({134 ...params,135 extraQ,136 });137 }138
139 /**140 * Lists folders.141 */142 async listFolders(params = {}) {143 const defaults = {144 preListLogMsgFunction: ({ page, enableLog = false }) => enableLog && console.log(`Getting folders (page ${page})...`),145 afterListLogMsgFunction: ({ folders, enableLog = false }) => enableLog && console.log(`We found ${folders.length} folders`),146 };147 const {148 extraQ,149 pageSize = 1000,150 token = '',151 fields = 'nextPageToken, files(id, name, parents)',152 root = false,153 trashed = false,154 spaces = 'drive',155 enableLog = false,156 folderList = [],157 page = 1,158 preListLogMsgFunction = defaults.preListLogMsgFunction,159 afterListLogMsgFunction = defaults.afterListLogMsgFunction,160 } = params;161 const mimeType = 'application/vnd.google-apps.folder';162
163 preListLogMsgFunction({ page, enableLog });164
165 const q = this.buildQuery({166 mimeType,167 root,168 trashed,169 extraQ,170 });171 const { data } = await this._drive.files.list(172 {173 q,174 spaces,175 pageToken: token,176 pageSize,177 fields,178 },179 );180 Array.prototype.push.apply(folderList, data.files);181 const folders = data.nextPageToken182 ? await this.listFolders({183 extraQ,184 pageSize,185 token,186 fields,187 root,188 trashed,189 spaces,190 folderList,191 page: page + 1,192 })193 : folderList;194
195 if (folderList.length === data.files.length) {196 afterListLogMsgFunction({ folders, enableLog });197 }198 return folders;199 }200
201 /**202 * Lists root folders.203 */204 async listRootFolders(params = {}) {205 const {206 extraQ,207 pageSize = 1000,208 token = '',209 fields = 'nextPageToken, files(id, name, parents)',210 trashed = false,211 } = params;212
213 console.log('Getting root folders...');214
215 const rootFolders = await this.listFolders({216 extraQ,217 pageSize,218 token,219 fields,220 root: true,221 trashed,222 });223 console.log(`We found ${rootFolders.length} root folders.`);224 return rootFolders;225 }226
227 buildQuery({ mimeType, root, trashed, extraQ }) {228 const qArr = [];229 if (mimeType) qArr.push(`mimeType='${mimeType}'`);230 if (root) qArr.push('\'root\' in parents');231 if (typeof trashed === 'boolean') qArr.push(`trashed=${trashed}`);232 if (extraQ) qArr.push(`${extraQ}`);233 return qArr.join(' and ');234 }235
236 async createOrUpdateFile(params) {237 const searchFiles = await this.getFileData({ ...params });238
239 if (searchFiles.length > 0) return this.updateFile({ fileId: searchFiles[0].id, ...params });240
241 return this.createFile(params);242 }243
244 async getFileData(params) {245 const {246 resource: { name, parents },247 } = params;248
249 let extraQ = `name = '${name}'`;250 if (parents && parents.length > 0) {251 extraQ += ` and (${parents.map(p => `'${p}' in parents`)252 .join(' or ')})`;253 }254 return this.listFilesWithoutFolders({255 ...params,256 extraQ,257 });258 }259
260 async uploadFile(file, parentFolderId, filesProvider) {261 if (typeof file !== 'object') {262 throw new Error(`DriveService.copyFile(): Parameter "file" must be of type object, provided value was "${file}"`);263 }264 const name = filesProvider.getFileName(file.key);265 console.log(`Copying file ${name}...`);266
267 const params = {268 resource: {269 ...file.options.resource,270 name,271 parents: [parentFolderId],272 },273 media: {274 ...file.options.media,275 body: await filesProvider.getFileStream(file.key),276 },277 };278 return this.createOrUpdateFile(params);279 }280
281 async execute() {282 console.log('Executing operations...');283 const { operations } = this.config;284 let operationToExecute;285 for (const operation of operations) {286 const { type } = operation;287 switch (type) {288 case OPERATIONS_TYPES.UPLOAD: {289 const { source, destination: inputDestination } = operation;290 const destination = new Folder(inputDestination);291 operationToExecute = new UploadOperation({ source, destination });292 break;293 }294 case OPERATIONS_TYPES.FOLDERS_DELETE: {295 const { folder: opFolder } = operation;296 const folder = new Folder(opFolder);297 operationToExecute = new DeleteFolderOperation({ folder });298 break;299 }300
301 default: {302 throw new Error(`DriveService.execute(): Unknown operation type "${operation}"!`);303 }304 }305 await operationToExecute.execute(this);306 }307 }308
309 /**310 *311 * @param folder<Folder>312 * @return {Promise<{folderId: null}>}313 */314 async getFolderInfo(folder) {315 console.log(`Getting folder info ${folder}...`);316
317 this.checkFolderOrThrow(folder);318
319 const result = { folderId: null };320
321 const folders = folder.getFolders();322
323 let currentFolder;324
325 for (const folderEl of folders) {326 let searchedFolder;327 if (folderEl.root) {328 const searchFolders = await this.listFolders({329 extraQ: `name='${folderEl.name}'`,330 });331 searchedFolder = searchFolders.find((f) => {332 if (folderEl.id) return f.id === folderEl.id;333 return f.name === folderEl.name;334 });335 } else {336 const searchFolders = await this.listFolders({337 extraQ: `name = '${folderEl.name}' and '${currentFolder.id}' in parents`,338 });339
340
341 const { name } = folderEl;342 const { id } = currentFolder;343 searchedFolder = searchFolders.find(f => f.name === name && f.parents[0] === id);344 }345 if (!searchedFolder) {346 result.folderId = null;347 break;348 }349 currentFolder = searchedFolder;350 result.folderId = currentFolder.id;351 }352 return result;353 }354
355 async deleteFolder(folderId) {356 if (!folderId) throw new Error('Parameter "folderId" is not defined!');357
358 console.log(`Deleting folder with id ${folderId}...`);359
360 try {361 const result = await this._drive.files.delete({362 fileId: folderId,363 });364 if (result.code === 404 && result.message.includes('File not found')) {365 console.log(`Couldn't delete folder with id "${folderId}" because it doesn't exist`);366 }367 } catch (e) {368 if (e.message.includes(DRIVE_ERROR_MESSAGES.insufficientPermissions)) {369 throw new Error(`${DRIVE_ERROR_MESSAGES.insufficientPermissions} (id="${folderId}")`);370 }371 throw e;372 }373 }374
375 /**376 *377 * @param folder<Folder>378 * @return {Promise<{folderId: *}>}379 */380 async createFolder(folder) {381 this.checkFolderOrThrow(folder);382
383 console.log(`Creating folder ${folder}...`);384
385 const result = { folderId: null };386
387 const folders = folder.getFolders();388
389 let currentFolder;390
391 for (const folderEl of folders) {392 const params = {393 resource: {394 name: folderEl.name,395 mimeType: 'application/vnd.google-apps.folder',396 } };397 let searchedFolder;398 if (folderEl.root) {399 const searchFolders = await this.listFolders({400 root: !folderEl.id,401 extraQ: `name='${folderEl.name}'`,402 });403 searchedFolder = searchFolders.find((f) => {404 if (folderEl.id) return f.id === folderEl.id;405 return f.name === folderEl.name;406 });407 } else {408 const searchFolders = await this.listFolders({409 extraQ: `name = '${folderEl.name}' and '${currentFolder.id}' in parents` });410
411 const { name } = folderEl;412 const { id } = currentFolder;413 searchedFolder = searchFolders.find(f => f.name === name && f.parents[0] === id);414 }415 if (!searchedFolder) {416 if (currentFolder) params.resource.parents = [currentFolder.id];417 ({ data: currentFolder } = await this.createFile(params));418 } else {419 currentFolder = searchedFolder;420 }421
422 result.folderId = currentFolder.id;423 }424
425 console.log(`Folder created: folder="${folder}"\nid="${result.folderId}"`);426
427 return result;428 }429
430 checkFolderOrThrow(folder) {431 if (!folder || !(folder instanceof Folder)) {432 throw new Error(`Parameter "folder" must be an instance of Folder! provided value was ${JSON.stringify(folder)}`);433 }434 }435}436
437module.exports = Service;1module.exports = {2 GOOGLE_APIS: {3 CLIENT_ID: '211810992764-08fbq7f79jqch0ng652ukbl8d5dahook.apps.googleusercontent.com',4 REDIRECT_URI: 'urn:ietf:wg:oauth:2.0:oob',5 },6 OPERATIONS_TYPES: {7 UPLOAD: 'upload',8 FOLDERS_DELETE: 'folders-delete',9 },10};1const Apify = require('apify');2const Config = require('./Config');3const Service = require('./Service');4const { throwIfTimeout } = require('./utils');5
6Apify.main(async () => {7 const input = await Apify.getInput();8 console.log('Input:');9 console.dir(input, { depth: 8 });10
11
12 const config = new Config(input);13
14 const service = new Service(config);15 await service.init();16
17 const { isSetupMode, timeoutSecs } = config;18 if (!isSetupMode) {19 await Promise.race([20 service.execute(),21 throwIfTimeout(timeoutSecs),22 ]);23 }24 console.log('Actor finished');25});1const { Duplex } = require('stream');2const { OPERATIONS_TYPES } = require('./consts');3const { Folder } = require('./operations/helper');4
5const validateAndParseInput = (input) => {6 console.log('Validating and parsing input...');7
8 const defaults = {9 isSetupMode: false,10 timeoutSecs: 5 * 60,11 };12 const ERROR_LABEL = '[PARSE_INPUT__ERROR]';13 if (typeof input !== 'object') {14 throw new Error(`${ERROR_LABEL} Input must be a JSON object`);15 }16 const isSetupMode = input.isSetupMode || defaults.isSetupMode;17 const timeoutSecs = input.timeoutSecs18 ? Number(input.timeoutSecs)19 : defaults.timeoutSecs;20
21 const parsedOperations = [];22 let constants = {};23 if (!input.isSetupMode) {24 // TODO: Validate constants and parse them25 if (typeof input.constants === 'object') {26 // eslint-disable-next-line prefer-destructuring27 constants = input.constants;28 }29
30 if (!input.operations) {31 throw new Error(`${ERROR_LABEL} Input must have the "operations" field!`);32 }33 if (!Array.isArray(input.operations) || input.operations.length === 0) {34 throw new Error(`${ERROR_LABEL} Input field "operations" must be of type array and has at least one operation!`);35 }36
37 for (const operation of input.operations) {38 const { type } = operation;39 if (!type || !Object.values(OPERATIONS_TYPES).includes(type)) {40 throw new Error(`${ERROR_LABEL} Input operation type must be of type string and is a valid type, provided value was ${type}`);41 }42 // eslint-disable-next-line default-case43 switch (type) {44 case OPERATIONS_TYPES.UPLOAD: {45 const { source, destination: inputDestination } = operation;46 const folderParams = Folder.validateAndParse({ folder: inputDestination, constants });47 parsedOperations.push({ type, source, destination: folderParams });48 break;49 }50 case OPERATIONS_TYPES.FOLDERS_DELETE: {51 const { folder: inputFolder } = operation;52 const folderParams = Folder.validateAndParse({ folder: inputFolder, constants });53 parsedOperations.push({ type, folder: folderParams });54 break;55 }56 }57 }58 }59 return { isSetupMode, constants, operations: parsedOperations, timeoutSecs };60};61
62const bufferToStream = (buffer) => {63 const stream = new Duplex();64 stream.push(buffer);65 stream.push(null);66 return stream;67};68
69const throwIfTimeout = async (timeoutSecs = 60) => {70 await new Promise(resolve => setTimeout(resolve, timeoutSecs * 1000));71 throw new Error(`Actor didn't finish in required time (${timeoutSecs}).`);72};73
74module.exports = { validateAndParseInput, bufferToStream, throwIfTimeout };1const { typeCheck } = require('type-check');2
3class Folder {4 constructor(params) {5 this.validate(params);6 for (const paramKey of Object.keys(params)) {7 this[paramKey] = params[paramKey];8 }9 }10
11 validate(params) {12 if (!typeCheck('Object', params)) {13 throw new Error(`Folder: Parameter "params" must be of type object, provided value was ${JSON.stringify(params)}`);14 }15 if (!typeCheck('String', params.parentFolderId) && !typeCheck('String', params.parentFolderName)) {16 throw new Error('Folder: Parameter "params" must have at least one this fields: "parentFolderId", "parentFolderName".');17 }18 if (params.relativePath && !typeCheck('Maybe String', params.relativePath)) {19 throw new Error('Folder: Parameter "params" must have the field "relativePath" as "String".');20 }21 // TODO: Add support for folder path as String22 // if (typeCheck('String', params) && params === '') throw new Error(`Folder: Parameter "params" must not be empty string`);23 }24
25 getFolders() {26 const folders = [];27 folders.push({28 id: this.parentFolderId,29 name: this.parentFolderName,30 root: true,31 });32 if (this.relativePath) {33 for (const folderName of this.relativePath.split('/')) {34 folders.push({35 name: folderName,36 root: false,37 });38 }39 }40 return folders;41 }42
43 toString() {44 if (this.folderAsString) return this.folderAsString;45 const parent = (this.parentFolderName || '') + (this.parentFolderId ? `::${this.parentFolderId}` : '');46 const relative = this.relativePath ? `/${this.relativePath}` : '';47 const folderAsString = `{${parent}}${relative}`;48 this.folderAsString = folderAsString;49 return folderAsString;50 }51
52 static validateAndParse({ folder, constants }) {53 let folderParams = folder;54
55 if (typeCheck('String', folderParams) && folderParams.includes('constants.')) {56 folderParams = constants.find(c => c.name === folderParams.split('.')[1]);57 }58
59 return folderParams;60 }61}62
63module.exports = { Folder };1const Apify = require('apify');2
3const { OPERATIONS_TYPES } = require('../consts');4const { bufferToStream } = require('../utils');5const { Folder } = require('../operations/helper');6// const { Service } = require('../Service');7
8class KeyValueStoreFilesProvider {9 constructor({ id, forceCloud = false, files }) {10 this.id = id;11 this.forceCloud = forceCloud;12 this.files = files;13 this.kvStore = null;14 this.initPromise = this.init();15 }16
17 async init() {18 if (this.kvStore) return;19 this.kvStore = await Apify.openKeyValueStore(this.id, { forceCloud: this.forceCloud });20 }21
22 async getFileStream(key) {23 await this.initPromise;24 const buffer = await this.kvStore.getValue(key);25 return bufferToStream(buffer);26 }27
28 getFileName(key) {29 const file = this.files.find(f => f.key === key);30 if (!file) throw new Error(`[KeyValueStoreFilesProvider.getFileName()] File not found for key "${key}"`);31 let name;32 if (file.options.resource && file.options.resource.name) {33 // eslint-disable-next-line prefer-destructuring34 name = file.options.resource.name;35 } else {36 name = file.name ? file.name : file.key;37 }38 return name;39 }40}41
42class UploadOperation {43 /**44 *45 * @param {Object} source46 * @param {Folder} destination47 */48 constructor({ source, destination }) {49 // TODO: Validate parameters50 if (!destination || !(destination instanceof Folder)) {51 throw new Error('Parameter "destination" must be of type Folder');52 }53
54 this.source = source;55 this.destination = destination;56 }57
58 filesProvider() {59 if (this._filesProvider) return this._filesProvider;60 this._filesProvider = new KeyValueStoreFilesProvider(this.source);61 return this._filesProvider;62 }63
64 /**65 *66 * @param {Service} driveService67 * @return {Promise<void>}68 */69 async execute(driveService) {70 console.log(`Uploading files to ${this.destination}...`);71
72 const { folderId } = await driveService.createFolder(this.destination);73 const filesProvider = await this.filesProvider();74
75 const uploadedFiles = [];76 for (const file of filesProvider.files) {77 const uploadedFile = await driveService.uploadFile(file, folderId, filesProvider);78 const { status, statusText, data } = uploadedFile;79 uploadedFiles.push({ file, status, statusText, data });80 }81 await Apify.setValue('UPLOAD', uploadedFiles);82 }83}84
85class DeleteFolderOperation {86 constructor({ folder }) {87 if (!folder || !(folder instanceof Folder)) throw new Error('DeleteFolderOperation: Parameter "folder" must be of type Folder');88
89 this.folder = folder;90
91 // TODO: Validate parameters92 }93
94 async execute(driveService) {95 console.log(`Deleting folder ${this.folder}...`);96 const { folderId } = await driveService.getFolderInfo(this.folder);97 if (!folderId) {98 console.log('Couldn\'t delete folder because it doesn\'t exist');99 } else {100 await driveService.deleteFolder(folderId);101 }102 }103}104
105module.exports = {106 OPERATIONS_TYPES,107 UploadOperation,108 DeleteFolderOperation,109};1const path = require('path');2const { getLocalUserInfo } = require('apify-cli/src/lib/utils');3const { ENV_VARS } = require('apify-shared/consts');4
5const prepareEnv = () => {6 const userInfo = getLocalUserInfo();7 const { proxy, id: userId, token } = userInfo;8 if (proxy && proxy.password) process.env[ENV_VARS.PROXY_PASSWORD] = proxy.password;9 if (userId) process.env[ENV_VARS.USER_ID] = userId;10 if (token) process.env[ENV_VARS.TOKEN] = token;11 process.env[ENV_VARS.LOCAL_STORAGE_DIR] = path.join(process.cwd(), './apify_storage');12};13
14prepareEnv();15
16const Apify = require('apify');17
18const { log } = Apify.utils;19
20const cleanAndGetKeyValueStore = async (idOrName, options = {}) => {21 let kvs = await Apify.openKeyValueStore(idOrName, options);22 await kvs.drop();23 kvs = await Apify.openKeyValueStore(idOrName, options);24 return kvs;25};26
27
28Apify.main(async () => {29 prepareEnv();30 log.info('Preparing Apify platform for tests...');31 const LOCAL_GD_TEST_KVS_NAME = 'gd-test';32 const REMOTE_GD_TEST_KVS_NAME = 'gd-test-store';33 const localKvs = await Apify.openKeyValueStore(LOCAL_GD_TEST_KVS_NAME);34 const platformKvs = await cleanAndGetKeyValueStore(REMOTE_GD_TEST_KVS_NAME, { forceCloud: true });35 await localKvs.forEachKey(async (key, index, info) => {36 log.info(`[KVS: ${REMOTE_GD_TEST_KVS_NAME}] Writing content "${key}" (info: ${JSON.stringify(info)})`);37 await platformKvs.setValue(key, await localKvs.getValue(key));38 });39});