@mcpher/gas-fakes 1.0.2 → 1.0.4

package/README.md

@@ -36,7 +36,7 @@ gasfakes.json holds various location and behavior parameters to inform about you
   "documentId": null,
   "cache": "/tmp/gas-fakes/cache",
   "properties": "/tmp/gas-fakes/properties",
-  "scriptId": "1ey2fr74m4n9fwaqi9dsx9ye"
+  "scriptId": "1bc79bd3-fe02-425f-9653-525e5ae0b678"
 }
 ````
 | property   | type            | default                              | description                                                                                   |
@@ -157,9 +157,9 @@ I recommend you do this to make sure Auth it's all good before you start coding
 
 ### Global intialization
 
-This was a little problematic to sequence, but I wanted to make sure that any GAS services being imitated were available and initialized on the Node side, just as they are in GAS. At the time of writing these services are implemented. Only a subset of methods are currently available - the rest are work in progress.
+This was a little problematic to sequence, but I wanted to make sure that any GAS services being imitated were available and initialized on the Node side, just as they are in GAS. At the time of writing these services and classes are implemented. However, only a subset of methods are currently available for some of them - the rest are work in progress.
 
-v1.0.1 
+v1.0.3 
 - `DriveApp`
 - `ScriptApp`
 - `UrlFetchApp`
@@ -167,49 +167,43 @@ v1.0.1
 - `Sheets`
 - `CacheService`
 - `PropertiesService`
+- `Session`
+- `Blob`
+- `User`
 
 #### Proxies and globalThis
 
 Each service has a FakeClass but I needed the Auth cycle to be initiated and done before making them public. Using a proxy was the simplest approach.
 
-Here's the code for `ScriptApp`
+Here's the code for `Utilities`
 
 ```js
 
 /**
  * adds to global space to mimic Apps Script behavior
  */
-const name = "ScriptApp"
+import { Proxies } from '../../support/proxies.js'
+import { newFakeUtilities } from './fakeutilities.js';
 
-if (typeof globalThis[name] === typeof undefined) {
 
-  // initializing auth etc
-  Syncit.fxInit()
+// This will eventually hold a proxy for Utilties
+let _app = null
 
-  console.log(`setting ${name} to global`)
+/**
+ * adds to global space to mimic Apps Script behavior
+ */
+const name = "Utilities"
+if (typeof globalThis[name] === typeof undefined) {
   const getApp = () => {
-
-    // if it hasn't been intialized yet then do that
+    // if it hasnt been intialized yet then do that
     if (!_app) {
-
-      _app = {
-        getOAuthToken,
-        requireAllScopes,
-        requireScopes,
-        AuthMode: {
-          FULL: 'FULL'
-        }
-      }
-
-
+      console.log (`setting ${name} to global`)
+      _app = newFakeUtilities()
     }
     // this is the actual driveApp we'll return from the proxy
     return _app
   }
-
-
-  Proxies.registerProxy(name, getApp)
-
+  Proxies.registerProxy (name, getApp)
 }
 ```
 
@@ -349,14 +343,18 @@ The local version may have no knowledge of the Apps ScriptId. If you are using c
 ##### userId
 
 The userId is extracted from an accessToken and will match the id derived from Application Default Credentials. This means that you can logon as a different user to test user data isolation. All user level property and cache stores use the scriptId and userId to partition data.
-
 ##### documentId
 
 The documentId is only meaningful if you are working on a container bound scrip. We use the the documentId property of gasfakes.json to identify a container file.  All document level property and cache stores use the scriptId and documentId to partition data.
 
 ### Settings and temporary files
 
-As you will have noticed, there are various local support files for props/caching etc. Be careful that these do not get committed to a public repo if you are adding sensitive values to your stores.
+As you will have noticed, there are various local support files for props/caching etc. Be careful that these do not get committed to a public repo if you are adding sensitive values to your stores. Note that the real user Id is not used when creating files, but rather an encrypted version of it. This avoids real user ids being revealed in your file system.
+
+
+## Noticed differences
+
+I'll make a note here on trivial implementation differences. The main will be slight differences in error message text, which I'll normalize over time. Please report any differences in behavior you find in the repo issues.
 
 
 ## Help

package/package.json

@@ -1,6 +1,7 @@
 {
   "dependencies": {
     "@sindresorhus/is": "^7.0.1",
+    "archiver": "^7.0.1",
     "get-stream": "^9.0.1",
     "google-auth-library": "^9.15.0",
     "googleapis": "^144.0.0",
@@ -9,7 +10,8 @@
     "keyv-file": "^5.1.1",
     "make-synchronous": "^1.0.0",
     "mime": "^4.0.6",
-    "sleep-synchronously": "^2.0.0"
+    "sleep-synchronously": "^2.0.0",
+    "unzipper": "^0.12.3"
   },
   "type": "module",
   "scripts": {
@@ -17,7 +19,7 @@
     "pub": "npm publish --access public"
   },
   "name": "@mcpher/gas-fakes",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "main.js",
   "description": "A proof of concept implementation of Apps Script Environment on Node",
   "repository": "github:brucemcpherson/gas-fakes",

package/src/index.js

@@ -4,3 +4,5 @@ import './services/urlfetchapp/app.js'
 import './services/utilities/app.js'
 import './services/sheets/app.js'
 import './services/stores/app.js'
+import './services/session/app.js'
+import './services/advdrive/app.js'

package/src/services/advdrive/app.js

@@ -0,0 +1,31 @@
+// fake Apps Script DriveApp
+/**
+ * the idea here is to create a global entry for the singleton 
+ * before we actually have everything we need to create it. 
+ * We do this by using a proxy, intercepting calls to the 
+ * initial sigleton and diverting them to a completed one
+ */
+import { newFakeAdvDrive} from './fakeadvdrive.js'
+import { Proxies } from '../../support/proxies.js'
+
+// This will eventually hold a proxy for DriveApp
+let _app = null
+
+/**
+ * adds to global space to mimic Apps Script behavior
+ */
+const name = "Drive"
+if (typeof globalThis[name] === typeof undefined) {
+
+  const getApp = () => {
+    // if it hasne been intialized yet then do that
+    if (!_app) {
+      _app = newFakeAdvDrive()
+    }
+    // this is the actual driveApp we'll return from the proxy
+    return _app
+  }
+
+  Proxies.registerProxy (name, getApp)
+
+}

package/src/services/advdrive/fakeadvdrive.js

@@ -0,0 +1,252 @@
+/**
+ * Advanced drive service
+ */
+import { Proxies } from '../../support/proxies.js'
+import { notYetImplemented } from '../../support/constants.js'
+
+class FakeAdvDrive {
+  constructor() {
+
+  }
+  toString() {
+    return `AdvancedServiceIdentifier{name=drive, version=v3}`
+  }
+  getVersion() {
+    return 'v3'
+  }
+  get Files() {
+    return newFakeAdvDriveFiles(this)
+  }
+  get About() {
+    return newFakeAdvDriveAbout(this)
+  }
+  get Accessproposals() {
+    return notYetImplemented
+  }
+  get Apps() {
+    return notYetImplemented
+  }
+  get Changes() {
+    return notYetImplemented
+  }
+  get Channels() {
+    return notYetImplemented
+  }
+  get Comments() {
+    return notYetImplemented
+  }
+  get Drives() {
+    return notYetImplemented
+  }
+  get Operations() {
+    return notYetImplemented
+  }
+  get Permissions() {
+    return notYetImplemented
+  }
+  get Replies() {
+    return notYetImplemented
+  }
+  get Revisions() {
+    return notYetImplemented
+  }
+  get Teamdrives() {
+    return notYetImplemented
+  }
+
+}
+
+class FakeAdvDriveAbout {
+  constructor(drive) {
+    this.toString = drive.toString
+  }
+
+  // this is a schema and needs the fields parameter
+  get() {
+    return notYetImplemented
+  }
+}
+
+class FakeAdvDriveFiles {
+  constructor(drive) {
+    this.toString = drive.toString
+  }
+
+  listLabels() {
+    return notYetImplemented
+  }
+
+  emptyTrash() {
+    return notYetImplemented
+  }
+
+  update() {
+    return notYetImplemented
+  }
+
+  list() {
+    return notYetImplemented
+  }
+  remove() {
+    return notYetImplemented
+  }
+
+  download() {
+    return notYetImplemented
+  }
+
+  modifyLabels() {
+    return notYetImplemented
+  }
+
+  watch() {
+    return notYetImplemented
+  }
+
+  get() {
+    return notYetImplemented
+  }
+
+  create() {
+    return notYetImplemented
+  }
+
+  generateIds() {
+    return notYetImplemented
+  }
+
+  copy() {
+    return notYetImplemented
+  }
+
+  export() {
+    return notYetImplemented
+  }
+
+}
+
+const newFakeAdvDriveFiles = (...args) => Proxies.guard(new FakeAdvDriveFiles(...args))
+const newFakeAdvDriveAbout = (...args) => Proxies.guard(new FakeAdvDriveAbout(...args))
+export const newFakeAdvDrive = (...args) => Proxies.guard(new FakeAdvDrive)
+
+
+
+/* methods to implement
+toString: [Function],
+  getVersion: [Function],
+  newTeamDriveRestrictions: [Function],
+  newTeamDrive: [Function],
+  newLabelFieldModification: [Function],
+  newFileImageMediaMetadataLocation: [Function],
+  newRevision: [Function],
+  newComment: [Function],
+  newFile: [Function],
+  newContentRestriction: [Function],
+  newDrive: [Function],
+  newDriveCapabilities: [Function],
+  newFileVideoMediaMetadata: [Function],
+  newDriveBackgroundImageFile: [Function],
+  newResolveAccessProposalRequest: [Function],
+  newFileLabelInfo: [Function],
+  newTeamDriveBackgroundImageFile: [Function],
+  newFileContentHints: [Function],
+  newPermission: [Function],
+  newFileLinkShareMetadata: [Function],
+  newFileImageMediaMetadata: [Function],
+  newFileCapabilities: [Function],
+  newCommentQuotedFileContent: [Function],
+  newReply: [Function],
+  newFileContentHintsThumbnail: [Function],
+  newModifyLabelsRequest: [Function],
+  newUser: [Function],
+  newLabel: [Function],
+  newDownloadRestriction: [Function],
+  newLabelModification: [Function],
+  newPermissionPermissionDetails: [Function],
+  newDriveRestrictions: [Function],
+  newPermissionTeamDrivePermissionDetails: [Function],
+  newFileShortcutDetails: [Function],
+  newChannel: [Function],
+  newTeamDriveCapabilities: [Function],
+  About: { toString: [Function], get: [Function] },
+
+
+
+
+  Accessproposals: 
+   { toString: [Function],
+     resolve: [Function],
+     get: [Function],
+     list: [Function] },
+  Apps: { toString: [Function], get: [Function], list: [Function] },
+  Changes: 
+   { toString: [Function],
+     getStartPageToken: [Function],
+     watch: [Function],
+     list: [Function] },
+  Channels: { toString: [Function], stop: [Function] },
+  Comments: 
+   { toString: [Function],
+     get: [Function],
+     create: [Function],
+     update: [Function],
+     list: [Function],
+     remove: [Function] },
+  Drives: 
+   { toString: [Function],
+     hide: [Function],
+     get: [Function],
+     create: [Function],
+     update: [Function],
+     list: [Function],
+     remove: [Function],
+     unhide: [Function] },
+  Files: 
+   { toString: [Function],
+     listLabels: [Function],
+     emptyTrash: [Function],
+     update: [Function],
+     list: [Function],
+     remove: [Function],
+     download: [Function],
+     modifyLabels: [Function],
+     watch: [Function],
+     get: [Function],
+     create: [Function],
+     generateIds: [Function],
+     copy: [Function],
+     export: [Function] },
+  Operations: 
+   { toString: [Function],
+     cancel: [Function],
+     get: [Function],
+     list: [Function],
+     remove: [Function] },
+  Permissions: 
+   { toString: [Function],
+     get: [Function],
+     create: [Function],
+     update: [Function],
+     list: [Function],
+     remove: [Function] },
+  Replies: 
+   { toString: [Function],
+     get: [Function],
+     create: [Function],
+     update: [Function],
+     list: [Function],
+     remove: [Function] },
+  Revisions: 
+   { toString: [Function],
+     get: [Function],
+     update: [Function],
+     list: [Function],
+     remove: [Function] },
+  Teamdrives: 
+   { toString: [Function],
+     get: [Function],
+     create: [Function],
+     update: [Function],
+     list: [Function],
+     remove: [Function] } }
+*/

package/src/services/scriptapp/app.js

@@ -92,9 +92,9 @@ if (typeof globalThis[name] === typeof undefined) {
   // initializing auth etc
   Syncit.fxInit()
 
-  console.log(`setting ${name} to global`)
   const getApp = () => {
 
+    console.log(`setting ${name} to global`)
     // if it hasn't been intialized yet then do that
     if (!_app) {
 

package/src/services/session/app.js

@@ -0,0 +1,33 @@
+
+/**
+ * fake Apps Script Session
+ * the idea here is to create a global entry for the singleton 
+ * before we actually have everything we need to create it. 
+ * We do this by using a proxy, intercepting calls to the 
+ * initial sigleton and diverting them to a completed one
+ */
+
+import { Proxies } from '../../support/proxies.js'
+import { newFakeSession } from './fakesession.js'
+
+let _app = null
+
+/**
+ * adds to global space to mimic Apps Script behavior
+ */
+const name = "Session"
+if (typeof globalThis[name] === typeof undefined) {
+
+  const getApp = () => {
+    // if it hasn't been intialized yet then do that
+    if (!_app) {
+      console.log(`setting ${name} to global`)
+      _app = newFakeSession()
+    }
+    // this is the actual driveApp we'll return from the proxy
+    return _app
+  }
+
+  Proxies.registerProxy(name, getApp)
+
+}

package/src/services/session/fakesession.js

@@ -0,0 +1,45 @@
+import { newFakeUser} from './fakeuser.js'
+import { Auth } from '../../support/auth.js'
+import { Proxies } from '../../support/proxies.js'
+
+class FakeSession {
+  constructor () { 
+    this._activeUser = newFakeUser (Auth.getTokenInfo())
+  }
+  getActiveUser() {
+    return this._activeUser
+  }
+  /**
+   * there's no difference between active/effective on node
+   * @returns {string}
+   */
+  getEffectiveUser() {
+    return this.getActiveUser()
+  }
+  /**
+   * @returns {string}
+   */
+  getActiveUserLocale() {
+    const lang = process.env.LANG || ''
+    // it'll be a format like en_US.UTF-8 so we need to drop the encoding to be like apps script
+    return lang.replace(/\..*/,'')
+  }
+  /**
+   * this'll come from the manifest on Node (on Apps Script it'll be where the user is running from)
+   * it's the same as the timezone
+   * @returns {string}
+   */
+  getScriptTimeZone() {
+    return Auth.getTimeZone()
+  }
+  /**
+   * this'll be an encrypted user ID - same as the one used for property/cache stores identification
+   * it's the same as the timezone
+   * @returns {string}
+   */
+  getTemporaryActiveUserKey() {
+    return Auth.getHashedUserId()
+  }
+}
+
+export const newFakeSession = (...args) => Proxies.guard (new FakeSession(...args))

package/src/services/session/fakeuser.js

@@ -0,0 +1,32 @@
+import { Proxies } from '../../support/proxies.js'
+
+/**
+ * returned by Session.getActiveUser,getEffectiveUser()
+ * the only method documented nowadays is getEmail()
+ * @class FakeUser
+ */
+class FakeUser {
+  /**
+   * @param {object} p tokeninfo
+   * @param {string} p.email email
+   * @returns {FakeUser}
+   */
+  constructor ({email}) {
+    this.__email = email
+  }
+  getEmail () {
+    return this.__email
+  }
+  toString () {
+    return this.getEmail()
+  }
+}
+
+/**
+ * create a new FakeUser instance
+ * @param  {...any} args 
+ * @returns {FakeUser}
+ */
+export const newFakeUser = (...args) => {
+  return Proxies.guard(new FakeUser(...args))
+}

package/src/services/sheets/app.js

@@ -17,13 +17,14 @@ let _app = null
 const name = "SpreadsheetApp"
 
 if (typeof globalThis[name] === typeof undefined) {
-  console.log (`setting ${name} to global`)
+
   /**
    * @returns {FakeSpreadsheetApp}
    */
   const getApp = () => {
     // if it hasnt been intialized yet then do that
     if (!_app) {
+       console.log (`setting ${name} to global`)
       _app = newFakeSpreadsheetApp()
     }
     // this is the actual driveApp we'll return from the proxy

package/src/services/stores/app.js

@@ -21,11 +21,12 @@ let _cacheApp = null
  */
 const registerApp = (_app, name, kind) => {
   if (typeof globalThis[name] === typeof undefined) {
-    console.log(`setting ${name} to global`)
+
 
     const getApp = () => {
       // if it hasnt been intialized yet then do that
       if (!_app) {
+        console.log(`setting ${name} to global`)
         _app = newFakeService(kind)
       }
       // this is the actual driveApp we'll return from the proxy

package/src/services/stores/fakestores.js

@@ -160,9 +160,9 @@ class FakeStore {
     const scriptId = Auth.getScriptId()
     const documentId = Auth.getDocumentId()
 
-    let fileName = `${k}-${t}-${scriptId}`
+    let fileName = `${k}${t}-${scriptId}`
     if (this.type === StoreType.USER) {
-      fileName += `-${Auth.getUserId()}`
+      fileName += `-${Auth.getHashedUserId()}`
     }
     else if (this.type === StoreType.DOCUMENT && documentId) {
       fileName += `-${documentId}`

package/src/services/urlfetchapp/app.js

@@ -69,10 +69,11 @@ let _app = null
  */
 const name = "UrlFetchApp"
 if (typeof globalThis[name] === typeof undefined) {
-  console.log (`setting ${name} to global`)
+
   const getApp = () => {
     // if it hasne been intialized yet then do that
     if (!_app) {
+      console.log (`setting ${name} to global`)
       _app = {
         fetch
       }

package/src/services/utilities/app.js

@@ -1,18 +1,8 @@
-import sleepSynchronously from 'sleep-synchronously';
 import { Proxies } from '../../support/proxies.js'
-import { newBlob } from './fakeblob.js'
-import {Utils} from '../../support/utils.js'
-/**
- * a blocking sleep to emulate Apps Script
- * @param {number} ms number of milliseconds to sleep
- */
-const sleep = (ms) => {
-  Utils.assert.number (ms, `Cannot convert ${ms} to int.`)
-  sleepSynchronously(ms);
-}
+import { newFakeUtilities } from './fakeutilities.js';
 
 
-// This will eventually hold a proxy for DriveApp
+// This will eventually hold a proxy for Utilities
 let _app = null
 
 /**
@@ -20,19 +10,14 @@ let _app = null
  */
 const name = "Utilities"
 if (typeof globalThis[name] === typeof undefined) {
-  console.log (`setting ${name} to global`)
   const getApp = () => {
-    // if it hasne been intialized yet then do that
+    // if it hasnt been intialized yet then do that
     if (!_app) {
-      _app = {
-        sleep,
-        newBlob
-      }
+      console.log (`setting ${name} to global`)
+      _app = newFakeUtilities()
     }
     // this is the actual driveApp we'll return from the proxy
     return _app
   }
-
   Proxies.registerProxy (name, getApp)
-
 }

package/src/services/utilities/fakeblob.js

@@ -11,10 +11,10 @@ class FakeBlob {
   /**
    * 
    * @constructor 
-   * @param {byte[]} [data] data 
+   * @param {*} [data] data 
    * @param {string} [contentType]
    * @param {string} [name]
-   * @returns {FakeDriveFile}
+   * @returns {FakeBlob}
    */
   constructor(data, contentType, name) {
     this._data = Utils.settleAsBytes(data)
@@ -45,7 +45,7 @@ class FakeBlob {
   }
 
   copyBlob() {
-    return newBlob(this.getBytes(), this.getContentType(), this.getName())
+    return newFakeBlob(this.getBytes(), this.getContentType(), this.getName())
   }
 
   setBytes(data) {
@@ -72,4 +72,4 @@ class FakeBlob {
   }
 
 }
-export const newBlob = (...args) => Proxies.guard(new FakeBlob(...args))
+export const newFakeBlob = (...args) => Proxies.guard(new FakeBlob(...args))

package/src/services/utilities/fakeutilities.js

@@ -0,0 +1,105 @@
+import sleepSynchronously from 'sleep-synchronously';
+import { Proxies } from '../../support/proxies.js'
+import { newFakeBlob } from './fakeblob.js'
+import { Utils } from '../../support/utils.js'
+import { gzipType, zipType } from '../../support/constants.js'
+import { randomUUID } from 'node:crypto'
+import { gzipSync , gunzipSync} from 'node:zlib'
+import { Syncit } from '../../support/syncit.js';
+
+class FakeUtilities {
+  constructor() {
+
+  }
+  /**
+   * a blocking sleep to emulate Apps Script
+   * @param {number} ms number of milliseconds to sleep
+   */
+  sleep(ms) {
+    Utils.assert.number(ms, `Cannot convert ${ms} to int.`)
+    sleepSynchronously(ms);
+  }
+
+  /*
+  * @param {*} [data] data 
+  * @param {string} [contentType]
+  * @param {string} [name]
+  * @returns {FakeBlob}
+  */
+  newBlob(data, contentType, name) {
+    return newFakeBlob(data, contentType, name)
+  }
+  /**
+   * gets a uid
+   * @returns {string}
+   */
+  getUuid() {
+    return randomUUID()
+  }
+  /**
+   * gzip-compresses the provided Blob data and returns it in a new Blob object.
+   * @param {FakeBlob} blob 
+   * @param {string} [name]
+   * @returns {FakeBlob}
+   */
+  gzip(blob, name) {
+    // can set the name if required
+    const buffer = Buffer.from (blob.getBytes())
+    return this.newBlob (gzipSync(buffer), gzipType, (name || blob.getName() || 'archive.gz'))
+  }
+  /**
+   * Creates a new Blob object that is a zip file containing the data from the Blobs passed in.
+   * @param {FakeBlob[]} blobs
+   * @param {string} [name=archive.zip]
+   * @returns {FakeBlob}
+   */
+  zip(blobs, name = "archive.zip") {
+    // decided to use 'archiver' rather than zlib for this as the objective may be to create a file containing multiple files
+    // zlib only supports singe files
+    const zipped = Syncit.fxZipper ({blobs})
+    return newFakeBlob (zipped, zipType , name)
+  }
+
+  /**
+   * Takes a Blob representing a zip file and returns its component blobs.
+   * @param {FakeBlob} blob 
+   * @param {string} [name]
+   * @returns {FakeBlob[]}
+   */
+  unzip (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())
+  }
+
+  /**
+   * Uncompresses a Blob object and returns a Blob containing the uncompressed data.
+   * @param {FakeBlob} blob 
+   * @returns {FakeBlob}
+  */
+  ungzip(blob) {
+    const buffer = Buffer.from (blob.getBytes())
+    const name = blob.getName()
+    const newName =  name ? name.replace(/\.gz$/,"") : null
+    return this.newBlob (gunzipSync(buffer), null, newName)
+  }
+
+  base64Encode (data, charset) {
+    return Buffer.from(Utils.settleAsBytes(data,charset)).toString('base64')
+  }
+
+  base64EncodeWebSafe (data, charset) {
+    return Buffer.from(Utils.settleAsBytes(data,charset)).toString('base64url')
+  }
+
+  base64Decode (b64) {
+    return Utils.settleAsBytes (Buffer.from (b64, 'base64')) 
+  }
+
+  base64DecodeWebSafe (b64) {
+    return Utils.settleAsBytes (Buffer.from (b64, 'base64url')) 
+  }
+
+}
+
+export const newFakeUtilities = () => Proxies.guard(new FakeUtilities())

package/src/support/auth.js

@@ -1,5 +1,6 @@
 import { GoogleAuth } from 'google-auth-library'
 import is from '@sindresorhus/is'
+import { createHash } from 'node:crypto'
 
 const _authScopes = new Set([])
 
@@ -8,8 +9,14 @@ let _auth = null
 let _projectId = null
 let _tokenInfo = null
 let _accessToken = null
+let _manifest = null
+let _clasp = null
 
 let _settings = null
+const setManifest = (manifest) => _manifest = manifest
+const setClasp = (clasp) => _clasp = clasp
+const getManifest = () => _manifest
+const getClasp = () => _clasp
 const getSettings = () => _settings
 const getScriptId = () => getSettings().scriptId
 const getDocumentId = () => getSettings().documentId
@@ -29,10 +36,10 @@ const getAccessToken= () => {
   return _accessToken
 }
 
-
+const getTimeZone = () => getManifest().timeZone 
 const getUserId = () => getTokenInfo().sub
 const getTokenScopes = () => getTokenInfo().scope
-
+const getHashedUserId = () => createHash('md5').update(getUserId()+'hud').digest().toString('hex')
 
 
 /**
@@ -142,5 +149,12 @@ export const Auth = {
   getDocumentId,
   setSettings,
   getCachePath,
-  getPropertiesPath
+  getPropertiesPath,
+  getTokenInfo,
+  getHashedUserId,
+  setManifest,
+  setClasp,
+  getManifest,
+  getClasp,
+  getTimeZone
 }

package/src/support/constants.js

@@ -15,3 +15,8 @@ export const spreadsheetType = `${gooType}.spreadsheet`
 
 export const isGoogleType = (mimeType) => 
   mimeType && mimeType.substring(0,gooType.length) === gooType
+
+export const gzipType = 'application/x-gzip'
+export const zipType = 'application/zip'
+
+export const notYetImplemented = `That is not yet implemented - watch https://github.com/brucemcpherson/gas-fakes for progress`

package/src/support/syncit.js

@@ -4,8 +4,8 @@
 import makeSynchronous from 'make-synchronous';
 import path from 'path'
 import { Auth } from "./auth.js"
-
-
+import { randomUUID } from 'node:crypto'
+import mime from 'mime';
 
 const authPath = "../support/auth.js"
 const drapisPath = "../services/drive/drapis.js"
@@ -31,37 +31,146 @@ const cacheDefaultPath = "/tmp/gas-fakes/cache"
  */
 const getModulePath = (relTarget) => path.resolve(import.meta.dirname, relTarget)
 
+/**
+ * zipper
+ * @param {object} p
+ * @param {FakeBlob} p.blobs an array of blobs to be zipped
+ * @returns {FakeBlob} a combined zip file
+ */
+const fxZipper = ({ blobs }) => {
+
+  const fx = makeSynchronous(async ({ blobsContent }) => {
+
+    const { default: archiver } = await import('archiver')
+    const { getStreamAsBuffer } = await import('get-stream')
+    const { PassThrough } = await import('node:stream')
+
+    const passthrough = new PassThrough()
+
+    // just use the default compression level
+
+    const archive = archiver.create('zip', {})
+
+    const doArchive = async () => {
+
+      // warning could be non destructive
+      archive.on("warning", function (err) {
+        if (err.code === "ENOENT") {
+          console.log("....warning on archiver", err)
+        } else {
+          // throw error
+          return Promise.reject(err)
+        }
+      });
+
+      archive.on("error", function (err) {
+        return Promise.reject(err)
+      })
+
+      const result = getStreamAsBuffer(archive.pipe(passthrough))
+
+      blobsContent.forEach(f => {
+        archive.append(Buffer.from(f.bytes), { name: f.name })
+      })
+
+      archive.finalize()
+
+      return result.then(buffer => Array.from(buffer))
+
+    }
+
+    return doArchive()
+      .catch(err => {
+        console.log('...archiver failed with error', err)
+        return Promise.reject(err)
+      })
+
+  })
+
+
+  const dupCheck = new Set()
+  const blobsContent = blobs.map((f,i) => {
+    const ext = mime.getExtension(f.getContentType())
+    const name = f.getName() || `Untitled${i+1}${ext ? "."+ext : ""}`
+    if (dupCheck.has (name)) {
+      throw new Error(`Duplicate filename ${name} not allowed in zip`)
+    }
+    dupCheck.add (name)
+    return {
+      name,
+      bytes: f.getBytes()
+    }
+  })
+  // check we don't have duplicate names
+  
+
+  return fx({
+    blobsContent
+  })
+
+
+}
 
+/**
+ * Unzipper
+ * @param {object} p
+ * @param {FakeBlob} p.blob the blob containing the zipped files
+ * @returns {FakeBlob[]} each of the files unzipped
+ */
+const fxUnZipper = ({ blob }) => {
+
+  const fx = makeSynchronous(async ({ blobContent }) => {
+
+    const { default: unzipper } = await import('unzipper')
+    const { getStreamAsBuffer } = await import('get-stream')
+
+    const buffer = Buffer.from(blobContent.bytes)
+    const unzipped = await unzipper.Open.buffer(buffer)
+
+    const result = await Promise.all(unzipped.files.map(async file => {
+      const bytes = await getStreamAsBuffer(file.stream())
+
+      return {
+        bytes,
+        name: file.path
+      }
+    }))
+
+    return result
+  })
+
+  const blobContent = {
+    name: blob.getName(),
+    bytes: blob.getBytes()
+  }
+
+
+  return fx({
+    blobContent
+  })
+
+
+}
 /**
  * we dont want to generate a lot of async/sync calls so start by getting themanifest stuff out of the way
  * @param {string} [manifestPath ='./appsscript.json']
  * 
  */
-const fxInit = ({ 
-  manifestPath = manifestDefaultPath, 
-  claspPath = claspDefaultPath, 
+const fxInit = ({
+  manifestPath = manifestDefaultPath,
+  claspPath = claspDefaultPath,
   settingsPath = settingsDefaultPath,
   cachePath = cacheDefaultPath,
   propertiesPath = propertiesDefaultPath
 } = {}) => {
 
-  const fx = makeSynchronous(async ({ manifestPath, authPath, claspPath, settingsPath, mainDir, cachePath, propertiesPath }) => {
+  const fx = makeSynchronous(async ({ manifestPath, authPath, claspPath, settingsPath, mainDir, cachePath, propertiesPath, fakeId }) => {
 
     // get the settings and manifest
     const path = await import('path')
     const { readFile, writeFile, mkdir } = await import('node:fs/promises')
     const { Auth } = await import(authPath)
 
-    /// make a fake scriptid
-    const makeFakeId = (length = 24) => {
-      const seed = new Date().getTime()
-      let t = ''
-      while (t.length < length) {
-        t += Math.trunc(seed * Math.random()).toString(36)
-      }
-      return t.substring(0, length)
-    }
-
     // get a file and parse if it exists
     const getIfExists = async (file) => {
       try {
@@ -94,7 +203,7 @@ const fxInit = ({
     ])
 
     /// if we dont have a scriptId we need to check in clasp or make a fakeone
-    settings.scriptId = settings.scriptId || clasp.scriptId || makeFakeId()
+    settings.scriptId = settings.scriptId || clasp.scriptId || fakeId
 
     // if we don't have a documentID, then see if this is a bound one
     settings.documentId = settings.documentId || null
@@ -103,12 +212,12 @@ const fxInit = ({
     settings.cache = settings.cache || cachePath
     settings.properties = settings.properties || propertiesPath
 
-    console.log (`...cache will be in ${settings.cache}`)
-    console.log (`...properties will be in ${settings.properties}`)
+    console.log(`...cache will be in ${settings.cache}`)
+    console.log(`...properties will be in ${settings.properties}`)
 
     // now update all that if anything has changed
-    const strSet = JSON.stringify(settings,null,2)
-    if (JSON.stringify(_settings,null, 2) !== strSet) {
+    const strSet = JSON.stringify(settings, null, 2)
+    if (JSON.stringify(_settings, null, 2) !== strSet) {
       await mkdir(settingsDir, { recursive: true })
       console.log('...writing to ', settingsFile)
       writeFile(settingsFile, strSet, { flag: 'w' })
@@ -140,7 +249,9 @@ const fxInit = ({
       projectId,
       tokenInfo,
       accessToken,
-      settings
+      settings,
+      manifest,
+      clasp
     }
 
 
@@ -158,14 +269,17 @@ const fxInit = ({
     authPath: getModulePath(authPath),
     mainDir,
     cachePath,
-    propertiesPath
+    propertiesPath,
+    fakeId: randomUUID()
   })
   const {
     scopes,
     projectId,
     tokenInfo,
     accessToken,
-    settings
+    settings,
+    manifest,
+    clasp
   } = synced
 
   // set these values from the subprocess for the main project
@@ -174,6 +288,8 @@ const fxInit = ({
   Auth.setTokenInfo(tokenInfo)
   Auth.setAccessToken(accessToken)
   Auth.setSettings(settings)
+  Auth.setClasp(clasp)
+  Auth.setManifest(manifest)
   return synced
 
 }
@@ -363,5 +479,7 @@ export const Syncit = {
   fxDrive,
   fxDriveMedia,
   fxInit,
-  fxStore
+  fxStore,
+  fxZipper,
+  fxUnZipper
 }