@mcpher/gas-fakes 1.0.5 → 1.0.6

package/package.json

@@ -21,7 +21,7 @@
     "pub": "npm publish --access public"
   },
   "name": "@mcpher/gas-fakes",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "main": "main.js",
   "description": "A proof of concept implementation of Apps Script Environment on Node",
   "repository": "github:brucemcpherson/gas-fakes",

package/src/services/advdrive/fakeadvdrivefiles.js

@@ -1,9 +1,12 @@
 import { Proxies } from '../../support/proxies.js'
-import { notYetImplemented, isGood, throwResponse, minFields } from '../../support/helpers.js'
+import { notYetImplemented, isGood, throwResponse, minFields, isFolder } from '../../support/helpers.js'
 import { Syncit } from '../../support/syncit.js'
-import { getFromFileCache, improveFileCache, checkResponse } from '../../support/filecache.js';
-import {Utils} from '../../support/utils.js'
-const {is} = Utils
+import {  improveFileCache, checkResponse } from '../../support/filecache.js';
+import { Utils, mergeParamStrings } from '../../support/utils.js'
+
+const { is } = Utils
+
+const apiProp = 'files'
 
 /**
  * these apply to Drive.files
@@ -12,7 +15,7 @@ class FakeAdvDriveFiles {
   constructor(drive) {
     this.drive = drive
     this.name = 'Drive.Files'
-    this.apiProp = 'files'
+    this.apiProp = apiProp
   }
 
   toString() {
@@ -27,24 +30,14 @@ class FakeAdvDriveFiles {
     return notYetImplemented()
   }
 
-  update() {
-    return notYetImplemented()
-  }
+
 
   list(params = {}) {
     // this is pretty straightforward as the onus is on thecaller to provide a valid queryOb
     // and validation will be done by the api.
     // however to support caching, we'll fiddle with the fields parameter
-    const fob = params.fields && params.fields.files
-    if (fob) {
-      const far = tidyFieldsFar(fob)
-      params = {
-        ...params, fields: {
-          ...params.fields,
-          files: far.join(",")
-        }
-      }
-    }
+
+    params.fields = mergeParamStrings(params.fields || "", `files(${minFields})`)
 
     // sincify that call
     const { response, data } = Syncit.fxDrive({ prop: this.apiProp, method: 'list', params })
@@ -55,8 +48,11 @@ class FakeAdvDriveFiles {
     }
 
     // lets improve cache with any enhanced data we've found
+    /// extract out the fieldslist
+    const fields = params.fields.replace(/.*files\(([^)]*)\).*/,"$1")
+
     data.files.forEach(f => {
-      improveFileCache(f.id, f)
+      improveFileCache(f.id, f,fields)
     })
     return data
 
@@ -117,70 +113,70 @@ class FakeAdvDriveFiles {
    * @returns {Drive.File}
    */
   get(id, params = {}, { allow404 = true } = {}) {
-
-    // now clean up 
-    let far = tidyFieldsFar(params)
-
-    // the cache will check the fields it already has against those requested
-    const { cachedFile, good } = getFromFileCache(id, far)
-    if (good) return cachedFile
-
-
-    // we'll enhance the cache with the current value of any already fetched field by fetching it again
-    params = { ...params, fileId: id, fields: enhanceFar({ cachedFile, far }) }
-
-    // run as a sub process to unasync it
-    const { response, data: file } = Syncit.fxDrive({ prop: this.apiProp, method: 'get', params })
-
-    // maybe we need to throw an error
-    checkResponse(id, response, allow404)
-
-    // finally register in cache for next time
-    return improveFileCache(id, file)
+    const {data} = Syncit.fxDriveGet ({ id, params, allow404, allowCache: true }) 
+    return data
   }
 
   /**
    * ceate a file and optionally upload some data
    * @param {File} [file] file resource
    * @param {Blob} [blob] the mediadata 
+   * @param {string} [fields] (not and advanced drive option but allow me to use this from driveapp and avoid an extra fetch)
    */
-  create(file = {}, blob) {
+  create(file = {}, blob, fields,params) {
+
     if (!is.undefined(blob) && !Utils.isBlob(blob)) {
       throw new Error("The mediaData parameter only supports Blob types for upload.")
     }
-    const mimeType = file.mimeType || blob?.getContentType()
-    const name = file.name || blob?.getName() || (isFolder({ mimeType }) ? "New Folder" : "Untitled")
-    const result = Syncit.fxStreamUpMedia({ fields: minFields, blob, file: { ...file, mimeType, name } })
-    const { data, response } = result
-    checkResponse(data?.id, response, false)
-    improveFileCache(data.id, data)
-    return data
+
+    // must have some kind of name so derive if not given
+    const name = file.name || blob?.getName() || (isFolder(file) ? "New Folder" : "Untitled")
+    return updateOrCreate ({method: "create", file: { ...file, name }, blob, fields, params })
+
   }
 
   generateIds() {
     return notYetImplemented()
   }
 
+  /**
+   * patch a file and ioptionally upoad new content
+   * @param {Drive.File} file the resource metadata
+   * @param {string} fileId the fileid to update
+   * @param {FakeBlob} [blob] new media if required
+   * @param {string} [fields] (not and advanced drive option but allow me to use this from driveapp and avoid an extra fetch)
+   * @param {object} [params] any extra params
+   * @returns {Drive.File} updated
+   */
+  update(file, fileId, blob, fields,params) {
+    if (!is.nonEmptyString(fileId)) {
+      throw new Error(`API call to drive.files.update failed with error: Required`)
+    }
+    return updateOrCreate ({method: 'update', file,  blob, fileId , fields, params})
+  }
   /**
    * ceate a file and optionally upload some data
    * @param {File} [file] file resource to patch
    * @param {string} fileId the file to copy 
    * @param {object} [options] request options
    */
-  copy(file, fileId, options) {
+  copy(file, fileId, options={}) {
+
     if (!is.nonEmptyString(fileId)) {
-      throw new Error ("API call to drive.files.copy failed with error: Required")
+      throw new Error(`API call to drive.files.copy failed with error: Required`)
     }
+    const fields = mergeParamStrings(options.fields || "",minFields)
     const params = {
-      fields: minFields,
+      fields,
       fileId,
       resource: file
     }
 
-    const { response, data } =  Syncit.fxDrive({ prop: this.apiProp, method: 'copy', params, options })
+    const { response, data } = Syncit.fxDrive({ prop: apiProp, method: 'copy', params, options })
     checkResponse(data?.id, response, false)
-    improveFileCache(data.id, data)
+    improveFileCache(data.id, data,fields)
     return data
+
   }
 
   export() {
@@ -224,4 +220,25 @@ const enhanceFar = ({ cachedFile, far }) => {
   return far.join(",")
 }
 
+
+  /**
+   * ceate/patch a file and optionally upload some data
+   * update and copy are virtually the same payload
+   * @param {string} method the api method
+   * @param {File} [file] file resource to patch/create
+   * @param {string} fileId the file to update 
+   * @param {FakeBlob} [blob] blob if media is provided
+   */
+  const updateOrCreate = ( {method, file = {}, blob, fileId, fields="" , params}) => {
+    
+    if (!Utils.isNU(blob) && !Utils.isBlob(blob)) {
+      throw new Error("The mediaData parameter only supports Blob types for upload.")
+    }
+    fields = mergeParamStrings(fields, minFields)
+    // streamupmedia takes care of improving the cache
+    const result = Syncit.fxStreamUpMedia({ method, fields, blob, file , fileId, params })
+    const { data } = result
+    return data
+  }
+
 export const newFakeAdvDriveFiles = (...args) => Proxies.guard(new FakeAdvDriveFiles(...args))

package/src/services/driveapp/fakedriveapp.js

@@ -1,6 +1,6 @@
 import { FakeDriveFolder, newFakeDriveFolder } from './fakedrivefolder.js'
-import { newFakeFolderApp } from './fakefolderapp.js'
 import { newFakeDriveFile } from './fakedrivefile.js'
+import { newFakeFolderApp } from './fakefolderapp.js'
 import { notYetImplemented, isFolder } from '../../support/helpers.js'
 import { Proxies } from '../../support/proxies.js'
 /**
@@ -12,7 +12,6 @@ export class FakeDriveApp {
 
   constructor() {
     const rf = Drive.Files.get('root', {}, { allow404: true })
-    // because the parent folder prop isnt returned we'll spoof it
     this.__rootFolder = newFakeDriveFolder(rf)
     this.folderApp = newFakeFolderApp()
     this.__settleClass = (file) => isFolder(file) ? newFakeDriveFolder(file) : newFakeDriveFile(file)

package/src/services/driveapp/fakedrivefile.js

@@ -1,9 +1,12 @@
 import { FakeDriveMeta } from "./fakedrivemeta.js"
 import { Proxies } from '../../support/proxies.js'
-import { isFolder } from '../../support/helpers.js'
+import { isFolder, isFakeFolder, argsMatchThrow } from '../../support/helpers.js'
 import { Syncit } from "../../support/syncit.js"
 import { FakeDriveFolder } from "./fakedrivefolder.js"
 import { Utils } from "../../support/utils.js"
+import { settleAsBlob } from "../utilities/fakeblob.js"
+import {  improveFileCache } from "../../support/filecache.js"
+
 const { is } = Utils
 
 /**
@@ -65,48 +68,75 @@ class FakeDriveFile extends FakeDriveMeta {
     return this.__getDecorated("webContentLink")
   }
 
+  /**
+   * set the content to something else
+   * @param {string} content apparently this can only be a string and not a blob 
+   * @return {FakeDriveFile} self
+   */
+  setContent(content) {
+    // for param checking
+    const matchThrow = () => argsMatchThrow(Array.from(arguments))
+    // apps script does a toString on the arg rather than failing
+    if (!is.function (content?.toString)) {
+      matchThrow()
+    }
+    
+    // this remains its current mimetype even though its now text
+    const blob = settleAsBlob(content.toString(), this.getMimeType(), this.getName())
+    const data = Drive.Files.update({}, this.getId(), blob)
+    
+    // merge this with already known fields and improve cache
+    this.meta = {...this.meta, ...data}
+    improveFileCache(this.getId(), this.meta)
+    return this
+
+  }
+
   /**
    * make a copy
    * @param {FakeDriveFolder|string|null} [destinationOrName] where to copy it to/chaneg the name if required
    * @param {FakeDriveFolder} [destination] where to copy it to
    */
   makeCopy(destinationOrName, destination) {
-    
+
     // default is same name as copied file
     let name = this.__getDecorated("name")
 
     // default is the parent of the file to be copied
     let parents = this.__getDecorated("parents")
-    const nargs = arguments.length
 
     // for param checking
-    const metaFolder = (item) => isFolder(item?.meta) ? "DriveApp.Folder" : is(item)
-    const passedTypes = [metaFolder(destinationOrName), metaFolder(destination)]
-      .slice(0, nargs).map(Utils.capital).join(",")
-    const matchThrow = (mess = "") => {
-      throw new Error(`The parameters (${passedTypes}) don't match the method ${mess}`)
-    }
+    const matchThrow = () => argsMatchThrow(Array.from(arguments))
+
+    
+    // cant move the root folder
+    this.__preventRootDamage("copy", this)
 
     // check args make sense
     if (Utils.isNU(destination) && Utils.isNU(destinationOrName)) {
       // makecopy()
       // no args provided, we use the defaults
-    } else if (isFolder(destinationOrName?.meta)) {
+
+    } else if (isFakeFolder(destinationOrName)) {
       // makecopy (afolder)
       // destination is a folder, so no 2nd arg required
       parents = [destinationOrName.__getDecorated("id")]
       if (!Utils.isNU(destination)) matchThrow()
+
     } else if (!is.nonEmptyString(destinationOrName)) {
       // makecopy (notastring,...)
       // they tried to give a name but its not a string
       matchThrow()
-    } else if (isFolder(destination?.meta)) {
+
+    } else if (isFakeFolder(destination)) {
       // makecopy (a string,a folder)
       name = destinationOrName
       parents = [destination.__getDecorated("id")]
+
     } else if (Utils.isNU(destination)) {
       // makecopy (string)
       name = destinationOrName
+
     } else {
       // makecopy (string, notafolder)
       matchThrow()

package/src/services/driveapp/fakedriveiterators.js

@@ -72,7 +72,7 @@ export const getFilesIterator = ({
   assert.boolean(folderTypes)
   assert.boolean(fileTypes)
 
-  // DriveApp doesnt give option to specify these so this will be fixes
+  // DriveApp doesnt give option to specify these so this will be fixed
   const fields = `files(${minFields}),nextPageToken`
 
   /**
@@ -97,6 +97,8 @@ export const getFilesIterator = ({
 
 
         // format the results into the folder or file object
+        assert.array (data.files)
+        assert.function (DriveApp.__settleClass)
         tank = data.files.map(DriveApp.__settleClass)
 
       }
@@ -130,12 +132,16 @@ export const getParentsIterator = ({
 }) => {
   const { assert } = Utils
   assert.object(file)
-  assert.array(file.parents)
+  // if its rott folder can be null
+  const parents  = is.null (file.parents) ? [] : file.parents
+  assert.array(parents)
 
   function* filesink() {
-    // the result tank, we just get them all by id
-    let tank = file.parents.map(id => Drive.Files.get(id, {}, { allow404: false }))
+    // the result tank, we just get them all by id - will return the usual minfields
+    // and will also stick them in cache
+    let tank = parents.map(id => Drive.Files.get(id, {}, { allow404: false }))
 
+    // let them out, 1 at a time
     while (tank.length) {
       yield DriveApp.__settleClass(tank.splice(0, 1)[0])
     }
@@ -186,6 +192,7 @@ const fileLister = ({
     params.pageToken = pageToken
   }
 
+
   // this will have be synced from async
   try {
     const result = Drive.Files.list(params)

package/src/services/driveapp/fakedrivemeta.js

@@ -9,12 +9,15 @@
  */
 
 import is from '@sindresorhus/is';
-import { notYetImplemented } from '../../support/helpers.js'
-import { getParentsIterator, getPermissionIterator} from './fakedriveiterators.js';
+import { isFolder, notYetImplemented, argsMatchThrow, isFakeFolder, minFields } from '../../support/helpers.js'
+import { getParentsIterator, getPermissionIterator } from './fakedriveiterators.js';
 import { newFakeUser } from '../session/fakeuser.js';
+import { improveFileCache } from "../../support/filecache.js"
+
 
 /**
  * basic fake File meta data
+ * these are shared between folders and files
  * @class FakeDriveMeta
  * @returns {FakeDriveMeta}
  */
@@ -27,9 +30,19 @@ export class FakeDriveMeta {
    */
   constructor(meta) {
     this.meta = meta
-
+    this.__gas_fake_service = "DriveApp"
   }
 
+  __preventRootDamage = (operation) => {
+    if (this.__isRoot) {
+      console.log (`Can't do ${operation} on root folder`)
+      throw new Error("Access denied: DriveApp")
+    }
+  }
+  get __isRoot () {
+    const parents = this.__getDecorated("parents")
+    return is.null (parents)
+  }
   /**
    * for enhancing the file with fields not retrieved by default
    * @param {string} fields='' the required fields
@@ -41,7 +54,6 @@ export class FakeDriveMeta {
       throw new Error('decorate fields was not a non empty string')
     }
     const sf = fields.split(",")
-
     if (sf.every(f => Reflect.has(this.meta, f))) {
       return this
     }
@@ -49,9 +61,17 @@ export class FakeDriveMeta {
     const newMeta = Drive.Files.get(this.getId(), { fields }, { allow404: false })
     // need to merge this with already known fields
     this.meta = { ...this.meta, ...newMeta }
+    improveFileCache (this.getId(), this.meta, fields)
     return this
   }
 
+  /**
+   * this will return the type DriveApp.Folder or DriveApp.File
+   * return {string}
+   */
+  __getFakeType() {
+    return isFolder(this.meta) ? "DriveApp.Folder" : "DriveApp.File"
+  }
   /**
    * the meta data for the following fields are not fetched by default
    */
@@ -59,6 +79,33 @@ export class FakeDriveMeta {
     return this.__decorateWithFields(prop).meta[prop]
   }
 
+  /** 
+   * __updateMeta - used to set simple felds using update
+   * @param {string} prop the meta data to set
+   * @param {*} value what to set it to
+   * @param {string} type whhat type it should be
+   * @param {object} args array like item with what was passed to the original function
+   * @returns this self
+   */
+  __updateMeta(prop, value, type, ...args) {
+
+    // cant update any meta on root folder
+    this.__preventRootDamage (`set ${prop}`)
+    
+    const matchThrow = () => argsMatchThrow(args)
+    if (!is[type](value)) {
+      matchThrow()
+    }
+    const file = {}
+    file[prop] = value
+
+    const data = Drive.Files.update(file, this.getId(), null, prop)
+    this.meta = {...this.meta, ...data}
+    improveFileCache (this.getId(), data)
+    
+    return this
+  }
+
   // shared between folder and file
   toString() {
     return this.getName()
@@ -144,34 +191,116 @@ export class FakeDriveMeta {
     return getSharers(this.getId(), 'writer')
   }
 
+  /**
+   * get the file url
+   * @returns {string} the webviewlink
+   */
   getUrl() {
     return this.__getDecorated("webViewLink")
   }
 
+  /**
+   * moves a file to a mew destination
+   * @param {FakeDriveFolder} destination
+   * @returns self for chaining
+   */
+  moveTo(destination) {
+    // prepare for any arg errors
+    const matchThrow = () => argsMatchThrow(Array.from(arguments))
+    if (!isFakeFolder(destination)) {
+      matchThrow()
+    }
+    // pick up parents for destination if not already known
+    const newParent = destination.getId()
+    if (!is.nonEmptyString(newParent)) {
+      throw new Error (`expected to find destination id as a string but got ${newParent}`)
+    }
+
+    // cant move the root folder
+    this.__preventRootDamage("move")
 
+    // we cant just fix the resource parents, we have to add and remove
+    // so that's a 2 step
+    const params = {
+      addParents: newParent,
+      removeParents: this.__getDecorated("parents")[0]
+    }
 
-  // TODO-----------
+    // need to make sure we get the new parents field back to improve cache with
+    const data = Drive.Files.update({}, this.getId(), null, "parents", params)
+
+    // merge this with already known fields and improve cache   
+    this.meta = { ...this.meta, ...data }
+
+    improveFileCache(this.getId(), this.meta)
+    return this
+
+  }
+
+  /**
+   * @param {string} value the updated value
+   * @returns {FakeDriveFile|FakeDriveFolder} this self
+   */
+  setDescription(value) {
+    return this.__updateMeta("description", value, "string", arguments)
+  }
+
+  /**
+   * @param {string} value the updated value
+   * @returns {FakeDriveFile|FakeDriveFolder} this self
+   */
+  setName(value) {
+    return this.__updateMeta("name", value, "string", arguments)
+  }
+
+  /**
+   * Sets whether users with edit permissions to the Folder are allowed to share with other users or change the permissions. 
+   * @param {boolean} value the updated value
+   * @returns {FakeDriveFile|FakeDriveFolder} this self
+   */
+  setShareableByEditors(value) {
+    return this.__updateMeta("writersCanShare", value, "boolean", arguments)
+  }
+
+  /**
+   * Determines whether users with edit permissions to the Folder/File are allowed to share with other users or change the permissions
+   * @returns {Boolean}
+   */
+  isShareableByEditors() {
+    return this.__getDecorated("writersCanShare")
+  }
 
-  setDescription() {
-    return notYetImplemented('setDescription')
+  /**
+   * Sets whether the Folder/File is starred in the user's Drive. 
+   * @param {boolean} value the updated value
+   * @returns {FakeDriveFile|FakeDriveFolder} this self
+   */
+  setStarred(value) {
+    return this.__updateMeta("starred", value, "boolean", arguments)
   }
 
+  /**
+   * Whether the file has been trashed, either explicitly or from a trashed parent folder
+   * @param {boolean} value the updated value
+   * @returns {FakeDriveFile|FakeDriveFolder} this self
+   */
+  setTrashed(value) {
+    this.__preventRootDamage("trash")
+    return this.__updateMeta("trashed", value, "boolean", arguments)
+  }
 
+  // TODO-----------
 
   getSharingPermission() {
     return notYetImplemented('getSharingPermission')
   }
-  setTrashed() {
-    return notYetImplemented('setTrashed')
-  }
+
 
   getSharingAccess() {
     return notYetImplemented('getSharingAccess')
   }
 
-  setStarred() {
-    return notYetImplemented('setStarred')
-  }
+
   getResourceKey() {
     return notYetImplemented('getResourceKey')
   }
@@ -191,24 +320,13 @@ export class FakeDriveMeta {
   getAccess() {
     return notYetImplemented('getAccess')
   }
-  moveTo() {
-    return notYetImplemented('moveTo')
-  }
-
-  setName() {
-    return notYetImplemented('setName')
-  }
 
 
   revokePermissions() {
     return notYetImplemented('revokePermissions')
   }
-  isShareableByEditors() {
-    return notYetImplemented('isShareableByEditors')
-  }
-  setShareableByEditors() {
-    return notYetImplemented('setShareableByEditors')
-  }
+
+
   setOwner() {
     return notYetImplemented('setOwner')
   }

package/src/services/utilities/fakeblob.js

@@ -39,6 +39,10 @@ class FakeBlob {
     this._name = name || null
   }
 
+  toString () {
+    // oddly this just refurns the object name rather than converting content to string
+    return 'Blob'
+  }
 
   getBytes() {
     return this._data

package/src/services/utilities/fakeutilities.js

@@ -67,7 +67,7 @@ class FakeUtilities {
    * @returns {FakeBlob[]}
    */
   unzip (blob) {
-    const unzipped = Syncit.fxUnZipper ({blob})
+    const unzipped = Syncit.fxUnzipper ({blob})
     // the content type is lost in a zipped file, same as Apps Script behavior - which seems to be to use the extension to reassert content type
     return unzipped.map (f=> newFakeBlob (f.bytes, null, f.name)).map(f=>f.setContentTypeFromExtension())
   }