@mcpher/gas-fakes 2.0.6 → 2.0.8

package/debug_form.js

@@ -0,0 +1,43 @@
+import './main.js';
+import { Syncit } from './src/support/syncit.js';
+
+async function debug() {
+  Syncit.fxInit();
+  
+  try {
+    const resource = Forms.Form.create({
+      info: {
+        title: "Debug Form with Items"
+      }
+    });
+    const formId = resource.formId;
+    
+    // Add a text item
+    const updateRequest = {
+      requests: [{
+        createItem: {
+          item: {
+            title: "Question 1",
+            questionItem: {
+              question: {
+                textQuestion: { paragraph: false }
+              }
+            }
+          },
+          location: { index: 0 }
+        }
+      }]
+    };
+    
+    const updateResponse = Forms.Form.batchUpdate(updateRequest, formId);
+    console.log("Update Response:", JSON.stringify(updateResponse, null, 2));
+    
+    const fullForm = Forms.Form.get(formId);
+    console.log("Full Form Resource:", JSON.stringify(fullForm, null, 2));
+    
+  } catch (e) {
+    console.error("Error:", e);
+  }
+}
+
+debug();

package/package.json

@@ -4,21 +4,21 @@
   },
   "dependencies": {
     "@mcpher/fake-gasenum": "^1.0.6",
-    "@mcpher/gas-flex-cache": "^1.1.4",
-    "@modelcontextprotocol/sdk": "^1.20.2",
-    "@sindresorhus/is": "^7.0.1",
+    "@mcpher/gas-flex-cache": "^1.1.5",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@sindresorhus/is": "^7.2.0",
     "acorn": "^8.15.0",
     "archiver": "^7.0.1",
-    "commander": "^14.0.1",
-    "dotenv": "^17.2.3",
-    "fast-xml-parser": "^5.3.0",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "fast-xml-parser": "^5.3.6",
     "get-stream": "^9.0.1",
     "googleapis": "^170.1.0",
-    "got": "^14.4.7",
+    "got": "^14.6.6",
     "into-stream": "^8.0.1",
-    "keyv": "^5.5.0",
-    "keyv-file": "^5.1.3",
-    "mime": "^4.0.7",
+    "keyv": "^5.6.0",
+    "keyv-file": "^5.3.3",
+    "mime": "^4.1.0",
     "prompts": "^2.4.2",
     "sleep-synchronously": "^2.0.0",
     "unzipper": "^0.12.3",
@@ -33,7 +33,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "license": "MIT",
   "main": "main.js",
   "description": "An implementation of the Google Workspace Apps Script runtime: Run native App Script Code on Node and Cloud Run",
@@ -42,4 +42,4 @@
   "bin": {
     "gas-fakes": "gas-fakes.js"
   }
-}
+}

package/src/services/advdrive/fakeadvdrivepermissions.js

@@ -31,6 +31,21 @@ class FakeAdvDrivePermissions extends FakeAdvResource {
     return data;
   }
 
+  update(resource, fileId, permissionId, optionalArgs) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Drive.Permissions.update");
+    if (nargs < 3 || nargs > 4) matchThrow();
+
+    ScriptApp.__behavior.isAccessible(fileId, 'Drive', 'write');
+    const params = {
+      resource,
+      fileId,
+      permissionId,
+      ...(optionalArgs || {})
+    };
+    const { data } = this._call('update', params);
+    return data;
+  }
+
   delete(fileId, permissionId, optionalArgs) {
     const { nargs, matchThrow } = signatureArgs(arguments, "Drive.Permissions.delete");
     if (nargs < 2 || nargs > 3) matchThrow();

package/src/services/driveapp/fakedriveapp.js

@@ -4,6 +4,7 @@ import { newFakeFolderApp } from './fakefolderapp.js'
 import { notYetImplemented, isFolder } from '../../support/helpers.js'
 import { Proxies } from '../../support/proxies.js'
 import { Utils } from '../../support/utils.js'
+import { Access, Permission } from '../enums/driveenums.js'
 const { is } = Utils
 
 
@@ -157,10 +158,10 @@ export class FakeDriveApp {
     return notYetImplemented('enforceSingleParent')
   }
   get Access() {
-    return notYetImplemented('Access')
+    return Access
   }
   get Permission() {
-    return notYetImplemented('Permission')
+    return Permission
   }
 
 }

package/src/services/driveapp/fakedrivemeta.js

@@ -10,10 +10,12 @@
 
 import is from '@sindresorhus/is';
 import { isFolder, notYetImplemented, isFakeFolder, signatureArgs } from '../../support/helpers.js'
+import { Access, Permission } from '../enums/driveenums.js'
 import { getParentsIterator } from './driveiterators.js';
+import { getPermissionIterator } from '../../support/fileiterators.js';
 import { improveFileCache } from "../../support/filecache.js"
 import { getSharers } from '../../support/filesharers.js';
-import {slogger } from "../../support/slogger.js";
+import { slogger } from "../../support/slogger.js";
 /**
  * basic fake File meta data
  * these are shared between folders and files
@@ -34,13 +36,13 @@ export class FakeDriveMeta {
 
   __preventRootDamage = (operation) => {
     if (this.__isRoot) {
-      slogger.error (`Can't do ${operation} on root folder`)
+      slogger.error(`Can't do ${operation} on root folder`)
       throw new Error("Access denied: DriveApp")
     }
   }
-  get __isRoot () {
+  get __isRoot() {
     const parents = this.__getDecorated("parents")
-    return is.null (parents)
+    return is.null(parents)
   }
   /**
    * for enhancing the file with fields not retrieved by default
@@ -60,7 +62,7 @@ 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)
+    improveFileCache(this.getId(), this.meta, fields)
     return this
   }
 
@@ -89,7 +91,7 @@ export class FakeDriveMeta {
   __updateMeta(prop, value, type, ...args) {
 
     // cant update any meta on root folder
-    this.__preventRootDamage (`set ${prop}`)
+    this.__preventRootDamage(`set ${prop}`)
     const { matchThrow } = signatureArgs(arguments, "update")
 
     if (!is[type](value)) {
@@ -99,9 +101,9 @@ export class FakeDriveMeta {
     file[prop] = value
 
     const data = Drive.Files.update(file, this.getId(), null, prop)
-    this.meta = {...this.meta, ...data}
-    improveFileCache (this.getId(), data)
-    
+    this.meta = { ...this.meta, ...data }
+    improveFileCache(this.getId(), data)
+
     return this
   }
 
@@ -206,14 +208,14 @@ export class FakeDriveMeta {
   moveTo(destination) {
     // prepare for any arg errors
     const { matchThrow } = signatureArgs(arguments, "moveTo", "DriveApp.Folder")
-   
+
     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}`)
+      throw new Error(`expected to find destination id as a string but got ${newParent}`)
     }
 
     // cant move the root folder
@@ -262,6 +264,84 @@ export class FakeDriveMeta {
     return this.__updateMeta("writersCanShare", value, "boolean", arguments)
   }
 
+  /**
+   * Sets the sharing permission and access for the Folder/File.
+   * @param {import('../enums/driveenums.js').Access} access the access level
+   * @param {import('../enums/driveenums.js').Permission} permission the permission level
+   * @returns {FakeDriveFile|FakeDriveFolder} this self
+   */
+  setSharing(access, permission) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "setSharing");
+    if (nargs !== 2) matchThrow();
+
+    // Mapping Appsscript Access/Permission to Drive API role/type
+    // This is a simplified version, as setSharing usually affects "anyone" or "domain" permissions.
+    // In Drive API v3, it involves managing permissions with types 'anyone' or 'domain'.
+
+    // 1. Determine type based on access
+    let type;
+    let role;
+    let allowFileDiscovery = false;
+
+    if (access === Access.ANYONE || access === Access.ANYONE_WITH_LINK) {
+      type = 'anyone';
+      allowFileDiscovery = (access === Access.ANYONE);
+    } else if (access === Access.DOMAIN || access === Access.DOMAIN_WITH_LINK) {
+      type = 'domain';
+      allowFileDiscovery = (access === Access.DOMAIN);
+    } else if (access === Access.PRIVATE) {
+      // For PRIVATE, we typically remove any 'anyone' or 'domain' permissions.
+      const { permissions } = Drive.Permissions.list(this.getId());
+      permissions.forEach(p => {
+        if (p.type === 'anyone' || p.type === 'domain') {
+          Drive.Permissions.delete(this.getId(), p.id);
+        }
+      });
+      return this;
+    }
+
+    // 2. Determine role based on permission
+    if (permission === Permission.VIEW || permission === Permission.READ) {
+      role = 'reader';
+    } else if (permission === Permission.COMMENT) {
+      role = 'commenter';
+    } else if (permission === Permission.EDIT) {
+      role = 'writer';
+    } else {
+      throw new Error(`Unsupported permission level for setSharing: ${permission}`);
+    }
+
+    // 3. Find existing permission of this type or create new
+    const { permissions } = Drive.Permissions.list(this.getId(), {
+      fields: "permissions(id,role,type,allowFileDiscovery,domain)"
+    });
+    const existing = permissions.find(p => p.type === type);
+
+    if (existing) {
+      // If the identity fields (type, allowFileDiscovery, domain) have changed, we must delete and recreate
+      const domain = type === 'domain' ? Session.getActiveUser().getDomain() : undefined;
+      const identityChanged = existing.allowFileDiscovery !== allowFileDiscovery ||
+        (type === 'domain' && existing.domain !== domain);
+
+      if (identityChanged) {
+        Drive.Permissions.delete(this.getId(), existing.id);
+        const resource = { role, type, allowFileDiscovery };
+        if (type === 'domain') resource.domain = domain;
+        Drive.Permissions.create(resource, this.getId());
+      } else {
+        // Only role is writable in update
+        Drive.Permissions.update({ role }, this.getId(), existing.id);
+      }
+    } else {
+      const resource = { role, type, allowFileDiscovery };
+      if (type === 'domain') resource.domain = Session.getActiveUser().getDomain();
+      Drive.Permissions.create(resource, this.getId());
+    }
+
+    improveFileCache(this.getId(), null);
+    return this;
+  }
+
   /**
    * Determines whether users with edit permissions to the Folder/File are allowed to share with other users or change the permissions
    * @returns {Boolean}
@@ -320,12 +400,60 @@ export class FakeDriveMeta {
   // TODO-----------
 
   getSharingPermission() {
-    return notYetImplemented('getSharingPermission')
-  }
+    const pit = getPermissionIterator({ id: this.getId() });
+    let highest = Permission.NONE;
+
+    const rank = (p) => {
+      if (p === Permission.OWNER) return 6;
+      if (p === Permission.EDIT) return 5;
+      if (p === Permission.COMMENT) return 4;
+      if (p === Permission.VIEW || p === Permission.READ) return 3;
+      return 0;
+    }
 
+    while (pit.hasNext()) {
+      const p = pit.next();
+      let current = Permission.NONE;
+      if (p.type === 'anyone' || p.type === 'domain') {
+        if (p.role === 'owner') current = Permission.OWNER;
+        else if (p.role === 'writer') current = Permission.EDIT;
+        else if (p.role === 'commenter') current = Permission.COMMENT;
+        else if (p.role === 'reader') current = Permission.VIEW;
+
+        if (rank(current) > rank(highest)) {
+          highest = current;
+        }
+      }
+    }
+    return highest;
+  }
 
   getSharingAccess() {
-    return notYetImplemented('getSharingAccess')
+    const pit = getPermissionIterator({ id: this.getId() });
+    let highest = Access.PRIVATE;
+
+    const rank = (a) => {
+      if (a === Access.ANYONE) return 4;
+      if (a === Access.ANYONE_WITH_LINK) return 3;
+      if (a === Access.DOMAIN) return 2;
+      if (a === Access.DOMAIN_WITH_LINK) return 1;
+      return 0;
+    }
+
+    while (pit.hasNext()) {
+      const p = pit.next();
+      let current = Access.PRIVATE;
+      if (p.type === 'anyone') {
+        current = p.allowFileDiscovery ? Access.ANYONE : Access.ANYONE_WITH_LINK;
+      } else if (p.type === 'domain') {
+        current = p.allowFileDiscovery ? Access.DOMAIN : Access.DOMAIN_WITH_LINK;
+      }
+
+      if (rank(current) > rank(highest)) {
+        highest = current;
+      }
+    }
+    return highest;
   }
 
 
@@ -333,9 +461,6 @@ export class FakeDriveMeta {
     return notYetImplemented('getResourceKey')
   }
 
-  setSharing() {
-    return notYetImplemented('setSharing')
-  }
   getSecurityUpdateEligible() {
     return notYetImplemented('getSecurityUpdateEligible')
   }

package/src/services/enums/driveenums.js

@@ -0,0 +1,19 @@
+import { newFakeGasenum } from "@mcpher/fake-gasenum";
+
+export const Access = newFakeGasenum([
+  "ANYONE",
+  "ANYONE_WITH_LINK",
+  "DOMAIN",
+  "DOMAIN_WITH_LINK",
+  "PRIVATE"
+])
+
+export const Permission = newFakeGasenum([
+  "COMMENT",
+  "EDIT",
+  "NONE",
+  "ORGANIZER",
+  "OWNER",
+  "READ",
+  "VIEW"
+])

package/src/services/formapp/fakeform.js

@@ -627,8 +627,73 @@ export class FakeForm {
    * @returns {string} The form URL.
    */
   getPublishedUrl() {
-    return `https://docs.google.com/forms/d/e/${this.getId()}/viewform`;
+    return `https://docs.google.com/forms/d/${this.getId()}/viewform`;
   }
+
+  /**
+   * Internal method to get the correct responder URI from the API resource.
+   * @returns {string} The responder URI.
+   */
+  __getResponderUri() {
+    return this.__resource.responderUri;
+  }
+
+  /**
+   * Internal method to get scraped metadata from the published form with caching.
+   * @returns {object} The scraped metadata or null.
+   */
+  __getScrapedMetadata() {
+    if (this.__scrapedMetadata) return this.__scrapedMetadata;
+
+    const formFile = this.__file; 
+
+    // 1. Capture original state
+    const originalAccess = formFile.getSharingAccess();
+    const originalPermission = formFile.getSharingPermission();
+
+    try {
+      // 2. Open access temporarily
+      formFile.setSharing(DriveApp.Access.ANYONE_WITH_LINK, DriveApp.Permission.VIEW);
+
+      // 3. Fetch the HTML
+      const publishUrl = this.getPublishedUrl();
+      const formHtml = UrlFetchApp.fetch(publishUrl).getContentText();
+      
+      const metadata = { entryMap: {} };
+      const fbzxMatch = formHtml.match(/name="fbzx" value="([^"]+)"/);
+      if (fbzxMatch) metadata.fbzx = fbzxMatch[1];
+
+      const historyMatch = formHtml.match(/name="pageHistory" value="([^"]+)"/);
+      if (historyMatch) metadata.pageHistory = historyMatch[1];
+
+      // Scrape entry IDs. They are usually in a script block like FB_PUBLIC_LOAD_DATA_
+      // or just search for entry.ID in the HTML.
+      // A common pattern is [123456789, "Question Title", ...]
+      const entryMatches = formHtml.matchAll(/entry\.(\d+)/g);
+      for (const match of entryMatches) {
+        // This is a bit crude but might help identify all available entry IDs
+        metadata.entryMap[match[1]] = true;
+      }
+
+      this.__scrapedMetadata = metadata;
+      return metadata;
+
+    } catch (e) {
+      console.warn(`[gas-fakes] Failed to fetch form metadata: ${e.message}`);
+      return null;
+    } finally {
+      // 4. Reset to original state
+      formFile.setSharing(originalAccess, originalPermission);
+      }
+  }
+
+  /**
+   * Internal method to clear the scraped metadata cache.
+   */
+  __clearScrapedMetadata() {
+    this.__scrapedMetadata = null;
+  }
+
   /**
    * Gets the URL to respond to the form
    * https://github.com/brucemcpherson/gas-fakes/issues/111
@@ -645,6 +710,22 @@ export class FakeForm {
     return this.getPublishedUrl()
   }
 
+  /**
+   * Creates a new response to the form.
+   * @returns {import('./fakeformresponse.js').FakeFormResponse} The newly created form response.
+   */
+  createResponse() {
+    return newFakeFormResponse(this, { answers: {} });
+  }
+
+  /**
+   * Deletes all responses from the form.
+   * @returns {FakeForm} The form, for chaining.
+   */
+  deleteAllResponses() {
+    throw new Error('deleteAllResponses is not yet implemented in the fake environment because the Google Forms API v1 does not support deleting responses.');
+  }
+
   toString() {
     return 'Form';
   }

package/src/services/formapp/fakeformitem.js

@@ -114,7 +114,9 @@ export class FakeFormItem {
   }
 
   getId() {
-    return Utils.fromHex(this.__itemId);
+    const resource = this.__resource;
+    const hexId = resource.questionItem?.question?.questionId || this.__itemId;
+    return Utils.fromHex(hexId);
   }
 
   getIndex() {

package/src/services/formapp/fakeformresponse.js

@@ -1,6 +1,7 @@
 import { Proxies } from '../../support/proxies.js';
 import { newFakeItemResponse } from './fakeitemresponse.js';
 import { Utils } from '../../support/utils.js';
+import { formsCacher } from '../../support/formscacher.js';
 
 export const newFakeFormResponse = (...args) => {
   return Proxies.guard(new FakeFormResponse(...args));
@@ -20,7 +21,9 @@ export class FakeFormResponse {
     this.__form = form;
     this.__resource = resource;
   }
-
+  toString() {
+    return 'FormResponse';
+  }
   /**
    * Gets the email address of the respondent.
    * @returns {string} the respondent's email
@@ -83,4 +86,122 @@ export class FakeFormResponse {
     // Finally, sort the responses based on the item's index in the form.
     return itemResponses.sort((a, b) => a.getItem().getIndex() - b.getItem().getIndex());
   }
-}
+
+  /**
+   * Adds an item response to this form response.
+   * @param {import('./fakeitemresponse.js').FakeItemResponse} itemResponse The item response to add.
+   * @returns {FakeFormResponse} This form response, for chaining.
+   */
+  withItemResponse(itemResponse) {
+    if (!this.__resource.answers) {
+      this.__resource.answers = {};
+    }
+
+    // itemResponse.__answers is the internal array of answers.
+    // In the resource, answers are keyed by questionId.
+    itemResponse.__answers.forEach(answer => {
+      this.__resource.answers[answer.questionId] = answer;
+    });
+
+    return this;
+  }
+
+  /**
+   * Submits the response.
+   * @returns {FakeFormResponse} This form response, for chaining.
+   */
+  submit() {
+    const formId = this.__form.getId();
+    const responderUri = this.__form.__getResponderUri();
+    const url = responderUri.replace('/viewform', '/formResponse');
+    const payload = {};
+
+    this.getItemResponses().forEach(itemResponse => {
+      const item = itemResponse.getItem();
+      const response = itemResponse.getResponse();
+      const itemType = item.getType().toString();
+
+      if ((itemType === 'CHECKBOX_GRID' || itemType === 'GRID') && Array.isArray(response)) {
+        const gridRows = item.__resource.questionGroupItem?.questions || [];
+        
+        response.forEach((rowResponse, rowIndex) => {
+          if (rowResponse && (Array.isArray(rowResponse) ? rowResponse.length > 0 : true)) {
+            const rowQuestionIdHex = gridRows[rowIndex]?.questionId;
+            if (rowQuestionIdHex) {
+              const rowQuestionIdDecimal = Utils.fromHex(rowQuestionIdHex);
+              payload[`entry.${rowQuestionIdDecimal}`] = rowResponse;
+            }
+          }
+        });
+      } else {
+        const questionIdHex = item.__resource.questionItem?.question?.questionId;
+        if (questionIdHex) {
+           const questionIdDecimal = Utils.fromHex(questionIdHex);
+           payload[`entry.${questionIdDecimal}`] = response;
+        }
+      }
+    });
+
+    if (Object.keys(payload).length > 0) {
+      // Dynamic page history based on actual form structure
+      const pageCount = this.__form.getItems(FormApp.ItemType.PAGE_BREAK).length + 1;
+      payload.pageHistory = Array.from({length: pageCount}, (_, i) => i).join(',');
+      payload.fvv = '1';
+
+      // Use cached metadata if available
+      const metadata = this.__form.__getScrapedMetadata();
+      if (metadata?.fbzx) payload.fbzx = metadata.fbzx;
+
+      // Build the payload string manually to handle multiple values for the same key (checkboxes)
+      const payloadParts = [];
+      Object.keys(payload).forEach(key => {
+        const value = payload[key];
+        if (Array.isArray(value)) {
+          value.forEach(v => payloadParts.push(`${encodeURIComponent(key)}=${encodeURIComponent(v)}`));
+        } else {
+          payloadParts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+        }
+      });
+      const payloadString = payloadParts.join('&');
+
+      // we need to do many things here to allowe access to the form as there are no formapp methods to add reponses.
+      // first save the current file permissions
+      const formFile = this.__form.__file;
+
+      // 1. Capture the original state
+      const originalAccess = formFile.getSharingAccess();
+      const originalPermission = formFile.getSharingPermission();
+      // temporarily make the form public so we can submit a response
+      // 2. Open access: Anyone with the link can view (needed for submission)
+      formFile.setSharing(DriveApp.Access.ANYONE_WITH_LINK, DriveApp.Permission.VIEW);
+
+      try {
+
+        // --- SUBMISSION LOGIC ---
+        const response = UrlFetchApp.fetch(url, {
+          method: 'post',
+          payload: payloadString,
+          contentType: 'application/x-www-form-urlencoded',
+          muteHttpExceptions: true
+        });
+
+        if (response?.getResponseCode() !== 200) {
+          throw new Error(`Failed to submit form response: ${response.getResponseCode()}`);
+        }
+
+        // Successful submission, clear the scraped metadata cache to get a fresh fbzx next time
+        this.__form.__clearScrapedMetadata();
+
+      } finally {
+        // 3. Reset to exactly how it was before
+        formFile.setSharing(originalAccess, originalPermission);
+      }
+    }
+
+    // Invalidate the form cache because a new response has been submitted
+    formsCacher.clear(formId);
+
+
+    return this;
+  }
+}

package/src/services/urlfetchapp/app.js

@@ -13,12 +13,23 @@ import { Proxies } from '../../support/proxies.js'
  * @return {FakeHTTPResponse} UrlFetchApp flavor 
  */
 const responsify = (response) => {
+  if (!response) {
+    // Return a dummy response that identifies as an error
+    return {
+      getAllHeaders: () => ({}),
+      getResponseCode: () => 500,
+      getContentText: () => "UrlFetchApp: No response data available.",
+      getHeaders: () => ({}),
+      getBlob: () => null,
+      getContent: () => []
+    }
+  }
 
   // getAllHeaders()	Object	Returns an attribute/value map of headers for the HTTP response, with headers that have multiple values returned as arrays.
   const getAllHeaders = () => fixHeaders(response)
 
   // getResponseCode()	Integer	Get the HTTP status code (200 for OK, etc.) of an HTTP response
-  const getResponseCode = () => response.statusCode
+  const getResponseCode = () => response.statusCode || response.status || 500
 
   // getContentText()	String	Gets the content of an HTTP response encoded as a string.
   const getContentText = () => blobify(response).getDataAsString()

package/src/support/auth.js

@@ -197,6 +197,8 @@ const setAuth = async (scopes = [], mcpLoading = false) => {
 
         if (!tokenResponse.ok) {
           const errorText = await tokenResponse.text()
+          console.log ('... it looks like you forgot to enable domain-wide delegation for the service account')
+          console.log ('... rerun gas-fakes auth and check the instructions about enabling domain-wide delegation')
           throw new Error(`Failed to exchange JWT for token: ${errorText}`)
         }
 
@@ -333,6 +335,7 @@ export const responseSyncify = (result) => {
   if (!result) {
     return {
       status: 503, // Service Unavailable, a good representation for a worker-level failure
+      statusCode: 503,
       statusText: "Worker Error: No response object received from API call",
       error: {
         message: "Worker Error: No response object received from API call",
@@ -340,10 +343,15 @@ export const responseSyncify = (result) => {
     };
   }
   return {
-    status: result.status,
+    status: result.status || result.statusCode,
+    statusCode: result.status || result.statusCode,
     statusText: result.statusText,
-    responseUrl: result.request?.responseURL,
+    responseUrl: result.request?.responseURL || result.url,
     error: result.data?.error,
+    rawHeaders: result.rawHeaders,
+    headers: result.headers,
+    body: result.body,
+    rawBody: result.rawBody
   };
 };
 

package/src/support/fileiterators.js

@@ -24,7 +24,7 @@ export const getPermissionIterator = ({
     do {
       // if nothing in the tank, fill it upFdrive
       if (!tank.length) {
-        const data = Drive.Permissions.list(id, { fields: "nextPageToken,permissions(role,type,emailAddress,photoLink,domain,displayName)" })
+        const data = Drive.Permissions.list(id, { fields: "nextPageToken,permissions(id,role,type,emailAddress,photoLink,domain,displayName,allowFileDiscovery)" })
         const { permissions, nextPageToken } = data
 
         // the presence of a nextPageToken is the signal that there's more to come

package/src/support/sxfetch.js

@@ -12,8 +12,9 @@ const fixOptions = (options) => {
   if (options) {
     fixedOptions = { ...options }
     Object.keys(fixedOptions).forEach(k => {
-      if (k.match(/Content-Type/i)) {
-        fixedOptions.contentType = fixedOptions[k]
+      if (k.match(/Content-Type|contentType/i)) {
+        fixedOptions.headers = fixedOptions.headers || {}
+        fixedOptions.headers['Content-Type'] = fixedOptions[k]
         delete fixedOptions[k]
       }
       if (k.match(/payload/i)) {
@@ -25,6 +26,23 @@ const fixOptions = (options) => {
         delete fixedOptions[k]
       }
     })
+
+    // Apps Script UrlFetchApp behavior: 
+    // If the payload is an object and no content type is specified, 
+    // it defaults to application/x-www-form-urlencoded.
+    if (fixedOptions.body && typeof fixedOptions.body === 'object' && !fixedOptions.contentType) {
+      // If it's a Buffer or Stream, we shouldn't convert it. 
+      // But here we check for plain objects.
+      if (!(fixedOptions.body instanceof Buffer)) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(fixedOptions.body)) {
+          params.append(key, value);
+        }
+        fixedOptions.body = params.toString();
+        fixedOptions.headers = fixedOptions.headers || {};
+        fixedOptions.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+      }
+    }
   }
   return fixedOptions
 }
@@ -52,6 +70,17 @@ export const sxFetch = async (Auth, url, options, responseFields) => {
     const response = await got(url, {
       ...fixedOptions,
       responseType: 'buffer'
+    }).catch(err => {
+      if (err.response) {
+        const data = responseFields.reduce((p, c) => {
+          p[c] = err.response[c]
+          return p
+        }, {})
+        if (data.rawBody) data.rawBody = Array.from(data.rawBody);
+        if (data.body && Buffer.isBuffer(data.body)) data.body = Array.from(data.body);
+        err.data = data;
+      }
+      throw err;
     })
 
     // we cant return the response from this as it cant be serialized
@@ -93,4 +122,4 @@ export const sxFetchAll = async (Auth, requests, responseFields) => {
     if (!isString) delete options.url
     return sxFetch(Auth, url, options, responseFields)
   }))
-}
+}

package/src/support/sxretry.js

@@ -36,31 +36,47 @@ export const sxRetry = async (Auth, tag, func, options = {}) => {
       response = err.response;
     }
 
-    const redoCodes = [429, 500, 503, 408, 401]
-    const isRetryable = redoCodes.includes(error?.code) ||
-      redoCodes.includes(response?.status) ||
-      error?.code === 'ETIMEDOUT' ||
-      error?.code === 'ECONNRESET' ||
-      error?.cause?.code === 'ETIMEDOUT' ||
-      error?.cause?.code === 'ECONNRESET' ||
-      error?.message?.includes('ETIMEDOUT') ||
-      error?.message?.includes('ECONNRESET') ||
-      (response?.status === 403 && (
-        error?.message?.toLowerCase().includes('usage limit') ||
-        error?.message?.toLowerCase().includes('rate limit') ||
-        error?.errors?.some(e => ['rateLimitExceeded', 'userRateLimitExceeded', 'calendarUsageLimitsExceeded'].includes(e.reason))
-      )) ||
-      extraRetryCheck(error, response);
+    const redoCodes = [429, 500, 503, 408, 401];
+    const networkErrorCodes = [
+      'ETIMEDOUT',
+      'ECONNRESET',
+      'ENETDOWN',
+      'ENETUNREACH',
+      'ECONNREFUSED',
+      'EPIPE',
+      'EAI_AGAIN',
+      'EHOSTUNREACH'
+    ];
+    const status = response?.status || response?.statusCode;
+
+    let retryReason = redoCodes.includes(error?.code) ? error.code :
+      redoCodes.includes(status) ? status :
+        networkErrorCodes.includes(error?.code) ? error.code :
+          networkErrorCodes.includes(error?.cause?.code) ? error.cause.code :
+            networkErrorCodes.find(code => error?.message?.includes(code));
+
+    if (!retryReason && status === 403 && (
+      error?.message?.toLowerCase().includes('usage limit') ||
+      error?.message?.toLowerCase().includes('rate limit') ||
+      error?.errors?.some(e => ['rateLimitExceeded', 'userRateLimitExceeded', 'calendarUsageLimitsExceeded'].includes(e.reason))
+    )) {
+      retryReason = 'Rate Limit';
+    }
+
+    const isRetryable = !!retryReason || extraRetryCheck(error, response);
+    if (isRetryable && !retryReason) retryReason = 'Extra Check';
 
     if (isRetryable && i < maxRetries - 1) {
-      const isAuthError = error?.code === 401 || response?.status === 401;
+      const isAuthError = error?.code === 401 || status === 401;
       if (isAuthError) {
+        // Only retry auth error once
+        if (i > 0) break;
         Auth.invalidateToken();
         syncWarn(`Authentication error (401) on ${tag}. Invalidated token and retrying immediately...`);
       } else {
         const jitter = Math.floor(Math.random() * 1000);
         const totalDelay = delay + jitter;
-        syncWarn(`Retryable error on ${tag} (status: ${response?.status || error?.code}). Retrying in ${totalDelay}ms...`);
+        syncWarn(`Retryable error on ${tag} (status: ${status || error?.code}, reason: ${retryReason}). Retrying in ${totalDelay}ms...`);
         await sleep(totalDelay);
         delay *= 2;
       }
@@ -68,10 +84,26 @@ export const sxRetry = async (Auth, tag, func, options = {}) => {
     }
 
     if (error) {
+      if (isRetryable && i === maxRetries - 1) {
+        // We've exhausted retries. Mark the error message to indicate this.
+        const msg = `Max retries reached (${maxRetries}) for reason ${retryReason}: ${error.message}`;
+        if (!response) {
+          response = {
+            status: 504,
+            statusText: msg,
+            data: { error: { message: msg } }
+          };
+        } else {
+          response.data = response.data || {};
+          response.data.error = response.data.error || { message: error.message };
+          response.data.error.message = `Max retries reached (${maxRetries}) for reason ${retryReason}: ${response.data.error.message}`;
+        }
+      }
+
       if (!skipLog(error, response)) {
         syncError(`Failed in ${tag}`, error);
       }
-      return { data: null, response: responseSyncify(response) };
+      return { data: error.data || null, response: responseSyncify(response) };
     }
 
     return { data: response.data, response: responseSyncify(response) };