@mcpher/gas-fakes 1.0.0

package/src/services/scriptapp/app.js

@@ -0,0 +1,133 @@
+// fake script app to get oauth token from application default credentials on Apps Script
+// first set up and test ADC with required scopes - see https://ramblings.mcpher.com/application-default-credentials-with-google-cloud-and-workspace-apis
+// Note that all async type functions have been converted to synch to make it Apps Script like
+
+import { Syncit } from '../../support/syncit.js'
+import { Auth } from '../../support/auth.js'
+import { Proxies } from '../../support/proxies.js'
+
+/**
+ * fake ScriptApp.getOAuthToken 
+ * @return {string} token
+ */
+const getOAuthToken = () => {
+  // make a sync request in a subprocess to get an access token
+  return Syncit.fxGetAccessToken()
+}
+
+const limitMode = (mode) => {
+  if (mode !== ScriptApp.AuthMode.FULL) {
+    throw new Error(`only ${ScriptApp.AuthMode.FULL} is supported as mode for now`)
+  }
+  // the scopes from the manifest should have been set
+  if (!Auth.hasAuth()) {
+    throw new Error(`manifest hasnt been initialized`)
+  }
+  return mode
+}
+
+/**
+ * these have been converted with a sync version
+ * @param {ScriptApp.AuthMode} mode mode to check
+ * @returns null
+ */
+const requireAllScopes = (mode) => {
+  limitMode(mode)
+  return checkScopesMatch(Array.from(Auth.getAuthedScopes().keys()))
+}
+
+/**
+ * these have been converted with a sync version
+ * see https://developers.google.com/apps-script/reference/script/script-app#requireScopes(AuthMode,String)
+ * @param {ScriptApp.AuthMode} mode mode to check
+ * @param {string[]} required scopes required 
+ * @returns null
+ */
+const requireScopes = (mode, required) => {
+  // only supporting FULL for now
+  limitMode(mode)
+  return checkScopesMatch(required)
+}
+
+/**
+ * a sync version of token checking
+ * @param {string} token the token to check
+ * @returns {object} access token info
+ */
+const checkToken = (accessToken) => {
+  return Syncit.fxCheckToken(accessToken)
+}
+
+/**
+ * check that all scopes requested have been asked for
+ * @param {string[]} required 
+ * @returns null
+ */
+const checkScopesMatch = (required) => {
+
+  // we can do a sync version of the accesstoken fetch
+  const token = getOAuthToken()
+  const tokenInfo = checkToken(token)
+
+  // now we're syncronous all the way
+  const tokened = new Set(tokenInfo.scope.split(" "))
+
+  // see which ones are missing
+  const missing = required.filter(s => {
+    // setting this scope causes gcloud to block - but we dot need it anywat as the default ADC allow it, so we have to skip it
+    const ignore = "https://www.googleapis.com/auth/script.external_request"
+    // if drive is authorized and drive.readonly is required that's okay too
+    // if drive.readonly is authorized and drive is requested thats not
+    return !(s === ignore || tokened.has(s.replace(/\.readonly$/, "")))
+  })
+
+  if (missing.length) {
+    throw new Error(`These scopes are required but have not been authorized ${missing.join(",")}`)
+  }
+  return null
+
+}
+
+// This will eventually hold a proxy for ScriptApp
+let _app = null
+
+
+/**
+ * adds to global space to mimic Apps Script behavior
+ */
+const name = "ScriptApp"
+
+if (typeof globalThis[name] === typeof undefined) {
+
+  console.log ('setting script app to global')
+
+  const getApp = () => {
+
+    // if it hasn't been intialized yet then do that
+    if (!_app) {
+      
+      // we also need to do the manifest scopes thing and the project id
+      const projectId = Syncit.fxGetProjectId()
+      const manifest = Syncit.fxGetManifest()
+      Auth.setProjectId (projectId)
+      Auth.setManifestScopes(manifest)
+
+      _app = {
+        getOAuthToken,
+        requireAllScopes,
+        requireScopes,
+        AuthMode: {
+          FULL: 'FULL'
+        }
+      }
+
+
+    }
+    // this is the actual driveApp we'll return from the proxy
+    return _app
+  }
+
+
+  Proxies.registerProxy(name, getApp)
+
+}

package/src/services/urlfetchapp/app.js

@@ -0,0 +1,128 @@
+// fake Apps Script UrlFetchApp
+
+import { Auth } from '../../support/auth.js'
+import { Syncit } from '../../support/syncit.js'
+import { Proxies } from '../../support/proxies.js'
+// Note that all async type functions have been converted to synch ro make it Apps Script like
+
+
+/**
+ * make got response look like UrlFetchApp response
+ * @param {Response} reponse
+ * @return {FakeHTTPResponse} UrlFetchApp flavor 
+ */
+const responsify = (response) => {
+
+  // TODO test all these
+  // getAllHeaders()	Object	Returns an attribute/value map of headers for the HTTP response, with headers that have multiple values returned as arrays.
+  // need to identify the difference between this and getHeaders
+  const getAllHeaders = () => response.rawHeaders
+
+  // getResponseCode()	Integer	Get the HTTP status code (200 for OK, etc.) of an HTTP response
+  const getResponseCode = () => response.statusCode
+
+  // getContentText()	String	Gets the content of an HTTP response encoded as a string.
+
+  const getContentText = () => response.body
+
+  // getHeaders()	Object	Returns an attribute/value map of headers for the HTTP response.
+  const getHeaders = () => response.headers
+
+  /* TODO
+  getAs(contentType)	Blob	Return the data inside this object as a blob converted to the specified content type.
+  getBlob()	Blob	Return the data inside this object as a blob.
+  getContent()	Byte[]	Gets the raw binary content of an HTTP response.
+  getContentText(charset)	String	Returns the content of an HTTP response encoded as a string of the given charset.
+  */
+  return {
+    getAllHeaders,
+    getResponseCode,
+    getContentText,
+    getHeaders
+  }
+}
+
+// this has been syncified
+const fetch =  (url, options = {}) => {
+
+  // check options for method and provide default
+  options.method = options.method || "get"
+  options = Auth.googify(options)
+
+  const responseFields = [
+    'rawHeaders',
+    'statusCode',
+    'body',
+    'headers'
+  ]
+
+  const response = Syncit.fxFetch(url, options, responseFields)
+  return responsify(response)
+}
+
+
+// This will eventually hold a proxy for DriveApp
+let _app = null
+
+/**
+ * adds to global space to mimic Apps Script behavior
+ */
+const name = "UrlFetchApp"
+if (typeof globalThis[name] === typeof undefined) {
+
+  const getApp = () => {
+    // if it hasne been intialized yet then do that
+    if (!_app) {
+      _app = {
+        fetch
+      }
+    }
+    // this is the actual driveApp we'll return from the proxy
+    return _app
+  }
+
+  Proxies.registerProxy (name, getApp)
+
+}
+
+
+/** got reponse props
+  [ '_events', 'object' ],
+  [ '_readableState', 'object' ],
+  [ '_writableState', 'object' ],
+  [ 'allowHalfOpen', 'boolean' ],
+  [ '_destroy', 'function' ],
+  [ '_maxListeners', 'undefined' ],
+  [ '_eventsCount', 'number' ],
+  [ 'socket', 'object' ],
+  [ 'httpVersionMajor', 'number' ],
+  [ 'httpVersionMinor', 'number' ],
+  [ 'httpVersion', 'string' ],
+  [ 'complete', 'boolean' ],
+  [ 'rawHeaders', 'object' ],
+  [ 'rawTrailers', 'object' ],
+  [ 'joinDuplicateHeaders', 'undefined' ],
+  [ 'aborted', 'boolean' ],
+  [ 'upgrade', 'boolean' ],
+  [ 'url', 'string' ],
+  [ 'method', 'object' ],
+  [ 'statusCode', 'number' ],
+  [ 'statusMessage', 'string' ],
+  [ 'client', 'object' ],
+  [ '_consuming', 'boolean' ],
+  [ '_dumped', 'boolean' ],
+  [ 'req', 'object' ],
+  [ 'timings', 'object' ],
+  [ 'headers', 'object' ],
+  [ 'setTimeout', 'function' ],
+  [ 'trailers', 'object' ],
+  [ 'requestUrl', 'object' ],
+  [ 'redirectUrls', 'object' ],
+  [ 'request', 'object' ],
+  [ 'isFromCache', 'boolean' ],
+  [ 'ip', 'string' ],
+  [ 'retryCount', 'number' ],
+  [ 'ok', 'boolean' ],
+  [ 'rawBody', 'object' ],
+  [ 'body', 'string' ]
+ */

package/src/services/utilities/app.js

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

package/src/services/utilities/fakeblob.js

@@ -0,0 +1,73 @@
+import { Proxies } from '../../support/proxies.js'
+import { Utils } from '../../support/utils.js'
+import { isGoogleType } from '../../support/constants.js'
+
+import mime from 'mime';
+// Apps Script blob fake
+
+
+class FakeBlob {
+  /**
+   * 
+   * @constructor 
+   * @param {byte[]} [data] data 
+   * @param {string} [contentType]
+   * @param {string} [name]
+   * @returns {FakeDriveFile}
+   */
+  constructor(data, contentType, name) {
+    this._data = Utils.settleAsBytes(data)
+    this._contentType = contentType || 
+      (Utils.isString(data) ? 'text/plain' : null)
+    this._name = name || null
+  }
+
+
+  getBytes() {
+    return this._data
+  }
+
+  getContentType() {
+    return this._contentType
+  }
+
+  getName() {
+    return this._name
+  }
+
+  isGoogleType() {
+    return isGoogleType(this.getContentType())
+  }
+
+  getDataAsString(charset) {
+    return Utils.bytesToString(this._data, charset)
+  }
+
+  copyBlob() {
+    return newBlob(this.getBytes(), this.getContentType(), this.getName())
+  }
+
+  setBytes(data) {
+    this._data = Utils.assertType(data, 'array')
+    return this
+  }
+  setContentType(contentType) {
+    this._contentType = contentType
+    return this
+  }
+
+  setContentTypeFromExtension() {
+    return this.setContentType(mime.getType(this.getName()))
+  }
+
+  setDataFromString(string, charset) {
+    return this.setBytes(Utils.stringToBytes(string, charset))
+  }
+
+  setName(name) {
+    this._name = name
+    return this
+  }
+
+}
+export const newBlob = (...args) => Proxies.guard(new FakeBlob(...args))

package/src/support/auth.js

@@ -0,0 +1,154 @@
+import { GoogleAuth } from 'google-auth-library'
+import {readFile} from 'node:fs/promises'
+import got from 'got'
+import path from 'path'
+import {Utils} from './utils.js'
+
+const _authScopes = new Set([])
+let _auth = null
+let _projectId = null
+
+const setProjectId = (projectId) => _projectId = projectId
+const setManifestScopes = (manifest) => setAuth(Utils.arrify(manifest.oauthScopes))
+
+/**
+ * get the manifest scopes and set them
+ * @param {string} [manifestParh] the manifest file path
+ * @returns {Promise <string[]>} the scopes
+ */
+const initManifestScopes = async (manifestParh) => {
+  const scopes = await getManifestScopes(manifestParh)
+  setAuth (scopes)
+  // we also set the project id to avoid catching that every time
+  // the project id is required for fetches to workspace apis using application default credentials
+  _projectId = await authProjectId()
+  return scopes
+}
+/**
+ * get the manifest content and parse
+ * @param {string} [manifestPath] the manifest file path
+ * @returns {Promise <object>} the manifest
+ */
+const getManifest = async (manifestPath='./appsscript.json') => {
+  const mainDir = path.dirname(process.argv[1])
+  const manifestFile = path.resolve ( mainDir, manifestPath) 
+  console.log (`using manifest file:${manifestFile}`) 
+  const contents = await readFile(manifestFile, { encoding: 'utf8' })
+  return JSON.parse (contents)
+}
+
+/**
+ * get the scopes from the manifest
+ * @param {string} [path] the manifest file path
+ * @returns {Promise <string[]>} the scopes required by the manifest 
+ */
+const getManifestScopes = async (path) => {
+  const manifest = await getManifest(path)
+  return Utils.arrify(manifest.oauthScopes)
+}
+/**
+ * we'll be using adc credentials so no need for any special auth here
+ * the idea here is to keep addign scopes to any auth so we have them all
+ * @param {string[]} [scopes=[]] the required scopes will be added to existing scopes already asked for
+ * @returns {GoogleAuth.auth}
+ */
+const setAuth = (scopes = []) => {
+
+  if (!hasAuth() || !scopes.every(s => _authScopes.has(s))) {
+    _auth = new GoogleAuth({
+      scopes
+    })
+    scopes.forEach(s => _authScopes.add(s))
+  }
+  return getAuth()
+}
+
+
+/**
+ * if we're doing a fetch on drive API we need a special header
+ */
+const googify = (options = {}) => {
+  const { headers } = options
+
+  // no auth, therefore no need
+  if (!headers || !hasAuth()) return options
+
+  // if no authorization, we dont need this either
+  if (!Reflect.has(headers, "Authorization")) return options
+
+  // we'll need the projectID for this
+  // note - you must add the x-goog-user-project header, otherwise it'll use some nonexistent project
+  // see https://cloud.google.com/docs/authentication/rest#set-billing-project
+  // this has been syncified
+  const projectId = getProjectId()
+  return {
+    ...options,
+    headers: {
+      "x-goog-user-project": projectId,
+      ...headers
+    }
+  }
+
+}
+/**
+ * @returns {Promise <string>} the projectId
+ */
+const authProjectId = async () => {
+  return getAuth().getProjectId()
+}
+
+/**
+ * this would have been set up when manifest was imported
+ * @returns {string} the project id
+ */
+const getProjectId = () => {
+  if (Utils.isNU(_projectId)) {
+    throw new Error ('Project id not set - did you forget to run initManifestScopes?')
+  }
+  return _projectId
+}
+
+/** 
+ * @returns {Boolean} checks to see if auth has bee initialized yet
+ */
+const hasAuth = () => Boolean (_auth)
+
+/**
+ * @returns {GoogleAuth.auth}
+ */
+const getAuth = () => {
+  if (!hasAuth()) throw new Error(`auth hasnt been intialized with setAuth yet`)
+  return _auth
+}
+
+/**
+ * gets the info about an access token
+ * @param {string} accessToken the accessToken to check
+ * @returns {Promise <object>} access toekn info
+ */
+
+const checkToken = async (accessToken) => {
+  const pack = await got(`https://www.googleapis.com/oauth2/v3/tokeninfo?access_token=${accessToken}`).json()
+  return pack
+}
+
+/**
+ * these are the ones that have been so far requested
+ * @returns {Set}
+ */
+const getAuthedScopes = () => _authScopes
+
+export const Auth = {
+  checkToken,
+  getAuth,
+  hasAuth,
+  getProjectId,
+  setAuth,
+  getManifestScopes,
+  getManifest,
+  initManifestScopes,
+  getAuthedScopes,
+  googify,
+  setProjectId,
+  setManifestScopes
+}

package/src/support/constants.js

@@ -0,0 +1,16 @@
+/**
+ * @constant
+ * @type {string}
+ * @default
+ */
+export const gooType = "application/vnd.google-apps"
+/**
+ * mimetype of a folder
+ * @constant
+ * @type {string}
+ * @default
+ */
+export const folderType = `${gooType}.folder`
+
+export const isGoogleType = (mimeType) => 
+  mimeType && mimeType.substring(0,gooType.length) === gooType

package/src/support/peeker.js

@@ -0,0 +1,44 @@
+import { Proxies } from './proxies.js'
+/**
+ * this is a class to add a hasnext to a generator
+ * @class Peeker
+ * 
+ */
+class Peeker {
+  /**
+   * @constructor 
+   * @param {function} generator the generator function to add a hasNext() to
+   * @returns {Peeker}
+   */
+  constructor(generator) {
+    this.generator = generator
+    // in order to be able to do a hasnext we have to actually get the value
+    // this is the next value stored
+    this.peeked = generator.next()
+  }
+
+  /**
+   * we see if there's a next if the peeked at is all over
+   * @returns {Boolean}
+   */
+  hasNext () {
+    return !this.peeked.done
+  }
+
+  /**
+   * get the next value - actually its already got and storef in peeked
+   * @returns {object} {value, done}
+   */
+  next () {
+    if (!this.hasNext()) {
+      // TODO find out what driveapp does
+      throw new Error ('iterator is exhausted - there is no more')
+    }
+    // instead of returning the next, we return the prepeeked next
+    const value = this.peeked.value
+    this.peeked = this.generator.next()
+    return value
+  }
+}
+
+export const newPeeker = (...args) => Proxies.guard(new Peeker (...args))

package/src/support/proxies.js

@@ -0,0 +1,74 @@
+
+
+/**
+ * diverts the property get to another object returned by the getApp function
+ * @param {function} a function to get the proxy object to substitutes
+ * @returns {function} a handler for a proxy
+ */
+const getAppHandler = (getApp) => {
+  return {
+
+    get(_, prop, receiver) {
+      // this will let the caller know we're not really running in Apps Script 
+      return (prop === 'isFake')  ? true : Reflect.get(getApp(), prop, receiver);
+    },
+
+    ownKeys(_) {
+      return Reflect.ownKeys(getApp())
+    }
+  }
+}
+
+const registerProxy = (name, getApp) => {
+  const value = new Proxy({}, getAppHandler(getApp))
+  // add it to the global space to mimic what apps script does
+  Object.defineProperty(globalThis, name, {
+    value,
+    enumerable: true,
+    configurable: false,
+    writable: false,
+  });
+}
+
+
+
+
+/**
+ * for validating attempts to access non existent properties
+ */
+const validateProperties = () => {
+  return {
+    get(target, prop, receiver) {
+      if (
+        // skip any inserted symbos
+        typeof prop !== 'symbol' &&
+        // sometimes typeof & console.log looks for ths
+        prop !== 'inspect' &&
+        // this is a mysterious property that APPS script sometimes checks for
+        prop !== '__GS_INTERNAL_isProxy' &&
+        // check the object has this property
+        !Reflect.has(target, prop)
+      )
+        throw new Error(`attempt to get non-existent property ${prop}: may not be implemented yet`)
+
+      return Reflect.get(target, prop, receiver);
+    },
+
+    set(target, prop, value, receiver) {
+      if (!Reflect.has(target, prop))
+        throw `guard attempt to set non-existent property ${prop}`;
+      return Reflect.set(target, prop, value, receiver);
+    },
+  };
+}
+
+ // used to trap access to unknown properties
+ const guard = (target) => {
+  return new Proxy(target, validateProperties);
+ }
+
+export const Proxies = {
+  getAppHandler,
+  registerProxy,
+  guard
+}