@mcpher/gas-fakes 2.0.5 → 2.0.7

package/README.md

@@ -181,6 +181,7 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [oddities](oddities.md) - a collection of oddities uncovered during this project
 - [named colors](named-colors.md)
 - [sandbox](sandbox.md)
+- [senstive scopes](senstive_scopes.md)
 - [using apps script libraries with gas-fakes](libraries.md)
 - [how libhandler works](libhandler.md)
 - [article:using apps script libraries with gas-fakes](https://ramblings.mcpher.com/how-to-use-apps-script-libraries-directly-from-node/)

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.5",
+  "version": "2.0.7",
   "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/index.js

@@ -8,6 +8,7 @@ import './services/utilities/app.js'
 import './services/spreadsheetapp/app.js'
 import './services/gmailapp/app.js'
 import './services/calendarapp/app.js'
+import './services/chartsapp/app.js'
 import './services/session/app.js'
 import './services/advdrive/app.js'
 import './services/advsheets/app.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/chartsapp/app.js

@@ -0,0 +1,8 @@
+/**
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
+ */
+import { lazyLoaderApp } from '../common/lazyloader.js'
+import { newFakeChartsApp as maker } from './fakechartsapp.js'
+let _app = null;
+_app = lazyLoaderApp(_app, 'Charts', maker)

package/src/services/chartsapp/fakechartsapp.js

@@ -0,0 +1,64 @@
+import { Proxies } from "../../support/proxies.js";
+import { notYetImplemented } from "../../support/helpers.js";
+import * as Enums from "../enums/chartsenums.js";
+
+/**
+ * create a new FakeChartsApp instance
+ * @param  {...any} args
+ * @returns {FakeChartsApp}
+ */
+export const newFakeChartsApp = (...args) => {
+  return Proxies.guard(new FakeChartsApp(...args));
+};
+
+/**
+ * basic fake FakeChartsApp
+ * @class FakeChartsApp
+ * @returns {FakeChartsApp}
+ */
+export class FakeChartsApp {
+  constructor() {
+    const enumProps = [
+      "ChartType", //	ChartType	An enumeration of the possible chart types.
+    ];
+
+    // import all known enums as props of chartsapp
+    enumProps.forEach((f) => {
+      this[f] = Enums[f];
+    });
+
+    const props = [
+      "newAreaChart",
+      "newBarChart",
+      "newColumnChart",
+      "newComboChart",
+      "newHistogramChart",
+      "newLineChart",
+      "newPieChart",
+      "newScatterChart",
+      "newSteppedAreaChart",
+      "newWaterfallChart",
+      "newScorecardChart",
+      "newRadarChart",
+      "newGaugeChart",
+      "newOrgChart",
+      "newTimelineChart",
+      "newTreeMapChart",
+      "newTableChart",
+      "newCandlestickChart",
+      "newGeoMapChart",
+      "newBubbleChart",
+      "newDataTable",
+      "newTextStyle",
+    ];
+
+    props.forEach((f) => {
+      this[f] = () => {
+        return notYetImplemented(f);
+      };
+    });
+  }
+  toString() {
+    return "Charts";
+  }
+}

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/chartsenums.js

@@ -0,0 +1,24 @@
+import { newFakeGasenum } from "@mcpher/fake-gasenum";
+
+export const ChartType = newFakeGasenum([
+  "AREA", //	Enum	Area chart.
+  "BAR", //	Enum	Bar chart.
+  "COLUMN", //	Enum	Column chart.
+  "COMBO", //	Enum	Combo chart.
+  "HISTOGRAM", //	Enum	Histogram chart.
+  "LINE", //	Enum	Line chart.
+  "PIE", //	Enum	Pie chart.
+  "SCATTER", //	Enum	Scatter chart.
+  "STEPPED_AREA", //	Enum	Stepped area chart.
+  "WATERFALL", //	Enum	Waterfall chart.
+  "SCORECARD", //	Enum	Scorecard chart.
+  "RADAR", //	Enum	Radar chart.
+  "GAUGE", //	Enum	Gauge chart.
+  "ORG", //	Enum	Org chart.
+  "TIMELINE", //	Enum	Timeline chart.
+  "TREE_MAP", //	Enum	Tree map chart.
+  "TABLE", //	Enum	Table chart.
+  "CANDLESTICK", //	Enum	Candlestick chart.
+  "GEOMAP", //	Enum	Geo map chart.
+  "BUBBLE", //	Enum	Bubble chart.
+]);

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/enums/sheetsenums.js

@@ -1,5 +1,5 @@
 
-import { newFakeGasenum} from "@mcpher/fake-gasenum";
+import { newFakeGasenum } from "@mcpher/fake-gasenum";
 export const AutoFillSeries = newFakeGasenum(["DEFAULT_SERIES", "ALTERNATE_SERIES"])
 export const BandingTheme = newFakeGasenum([
   "LIGHT_GREY", //	Enum	A light grey banding theme.

package/src/services/formapp/fakeform.js

@@ -629,6 +629,15 @@ export class FakeForm {
   getPublishedUrl() {
     return `https://docs.google.com/forms/d/e/${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;
+  }
+
   /**
    * Gets the URL to respond to the form
    * https://github.com/brucemcpherson/gas-fakes/issues/111
@@ -645,6 +654,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,94 @@ 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 = {};
+    console.log('url', url)
+    console.log('edit url', this.__form.getEditUrl())
+    console.log('responder uri', this.__form.__getResponderUri())
+    console.log('published url', this.__form.getPublishedUrl())
+    console.log('form id', this.__form.getId())
+
+
+    this.getItemResponses().forEach(itemResponse => {
+      const item = itemResponse.getItem();
+      const id = item.getId();
+      payload[`entry.${id}`] = itemResponse.getResponse();
+    });
+
+    if (Object.keys(payload).length > 0) {
+ 
+
+      // 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 {
+
+        // --- YOUR SUBMISSION LOGIC HERE ---
+        console.log("Form is temporarily public. Submitting...");
+        const response = UrlFetchApp.fetch(url, {
+          method: 'post',
+          payload,
+          muteHttpExceptions: true
+        });
+
+        if (response.getContentText().includes("recorded")) {
+          console.log("Success! Data pushed to Google Sheets.");
+        }
+
+        if (response?.getResponseCode() !== 200) {
+          throw new Error(`Failed to submit form response: ${response.getResponseCode()}`);
+        }
+
+      } catch (e) {
+        console.error("Submission failed: " + e.toString());
+      } finally {
+        // 3. Reset to exactly how it was before
+        // This closes the 401/403 hole immediately
+        formFile.setSharing(originalAccess, originalPermission);
+        console.log("Permissions reset to original state.");
+      }
+    }
+
+    // Invalidate the form cache because a new response has been submitted
+    formsCacher.clear(formId);
+
+
+    return this;
+  }
+}

package/src/services/spreadsheetapp/fakeembeddedchart.js

@@ -0,0 +1,87 @@
+import { Proxies } from "../../support/proxies.js";
+import { notYetImplemented, signatureArgs } from "../../support/helpers.js";
+import { batchUpdate } from "./sheetrangehelpers.js";
+import { newFakeEmbeddedChartBuilder } from "./fakeembeddedchartbuilder.js";
+
+/**
+ * @returns {FakeEmbeddedChart}
+ */
+export const newFakeEmbeddedChart = (apiChart, sheet) => {
+  return Proxies.guard(new FakeEmbeddedChart(apiChart, sheet));
+};
+
+/**
+ * Represents a chart that has been embedded into a spreadsheet.
+ */
+export class FakeEmbeddedChart {
+  /**
+   * @param {object} apiChart The EmbeddedChart object from Sheets API
+   * @param {FakeSheet} sheet The parent sheet
+   */
+  constructor(apiChart, sheet) {
+    this.__apiChart = apiChart;
+    this.__sheet = sheet;
+
+    const props = [
+      "getAs",
+      "getBlob",
+      "getContainerInfo",
+    ];
+    props.forEach((f) => {
+      this[f] = () => notYetImplemented(f);
+    });
+  }
+
+  /**
+   * Returns the ID of this chart.
+   * @returns {number}
+   */
+  getChartId() {
+    return this.__apiChart.chartId;
+  }
+
+  /**
+   * Returns the ID of this chart (alias for getChartId).
+   * @returns {string}
+   */
+  getId() {
+    return this.getChartId().toString();
+  }
+
+  /**
+   * Returns the options of this chart.
+   * @returns {object}
+   */
+  getOptions() {
+    return {
+      get: (key) => {
+        if (key === "title") return this.__apiChart.spec.title;
+        return this.__apiChart.spec.basicChart?.options?.[key];
+      }
+    };
+  }
+
+  /**
+   * Returns a builder to modify this chart.
+   * @returns {FakeEmbeddedChartBuilder}
+   */
+  modify() {
+    return newFakeEmbeddedChartBuilder(this.__sheet).setChartId(this.getChartId()).setApiChart(this.__apiChart);
+  }
+
+  /**
+   * Deletes the chart from the sheet.
+   */
+  remove() {
+    const request = {
+      deleteEmbeddedObject: {
+        objectId: this.getChartId(),
+      },
+    };
+    batchUpdate({ spreadsheet: this.__sheet.getParent(), requests: [request] });
+  }
+
+  toString() {
+    return "EmbeddedChart";
+  }
+}

package/src/services/spreadsheetapp/fakeembeddedchartbuilder.js

@@ -0,0 +1,154 @@
+import { Proxies } from "../../support/proxies.js";
+import { signatureArgs } from "../../support/helpers.js";
+import { Utils } from "../../support/utils.js";
+import { makeSheetsGridRange } from "./sheetrangehelpers.js";
+import { newFakeEmbeddedChart } from "./fakeembeddedchart.js";
+
+const { is } = Utils;
+
+/**
+ * @returns {FakeEmbeddedChartBuilder}
+ */
+export const newFakeEmbeddedChartBuilder = (sheet) => {
+  return Proxies.guard(new FakeEmbeddedChartBuilder(sheet));
+};
+
+/**
+ * Builder for embedded charts.
+ */
+export class FakeEmbeddedChartBuilder {
+  constructor(sheet) {
+    this.__sheet = sheet;
+    this.__apiChart = {
+      spec: {
+        title: "",
+        basicChart: {
+          chartType: "COLUMN", // Default
+          legendPosition: "RIGHT_LEGEND",
+          axis: [],
+          domains: [],
+          series: [],
+        },
+      },
+      position: {
+        overlayPosition: {
+          anchorCell: {
+            sheetId: sheet.getSheetId(),
+            rowIndex: 0,
+            columnIndex: 0,
+          },
+          offsetXPixels: 0,
+          offsetYPixels: 0,
+        },
+      },
+    };
+  }
+
+  setChartId(id) {
+    this.__apiChart.chartId = id;
+    return this;
+  }
+
+  setApiChart(apiChart) {
+    this.__apiChart = JSON.parse(JSON.stringify(apiChart));
+    return this;
+  }
+
+  addRange(range) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "EmbeddedChartBuilder.addRange");
+    if (nargs !== 1) matchThrow();
+
+    const gridRange = makeSheetsGridRange(range);
+
+    // In Sheets API, ranges are usually mapped to domains or series.
+    // Simplifying: if the range has multiple columns, split it into separate sources if it's a series.
+    // But for this fake, we'll just encourage the user to use single-column ranges or handle it simply.
+
+    if (this.__apiChart.spec.basicChart.domains.length === 0) {
+      this.__apiChart.spec.basicChart.domains.push({
+        domain: { sourceRange: { sources: [gridRange] } },
+      });
+    } else {
+      // Check if gridRange has multiple columns/rows and split if necessary?
+      // For now, just add it. The test will be updated to use single column ranges.
+      this.__apiChart.spec.basicChart.series.push({
+        series: { sourceRange: { sources: [gridRange] } },
+      });
+    }
+    return this;
+  }
+
+  setChartType(type) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "EmbeddedChartBuilder.setChartType");
+    if (nargs !== 1) matchThrow();
+
+    // type is Charts.ChartType enum (which should match API strings in our fakes)
+    this.__apiChart.spec.basicChart.chartType = type.toString();
+    return this;
+  }
+
+  /**
+   * Returns the chart type.
+   * @returns {ChartType}
+   */
+  getChartType() {
+    const spec = this.__apiChart.spec;
+    const chartType = Charts.ChartType;
+    if (spec.basicChart) return chartType[spec.basicChart.chartType];
+    if (spec.pieChart) return chartType.PIE;
+    if (spec.bubbleChart) return chartType.BUBBLE;
+    if (spec.candlestickChart) return chartType.CANDLESTICK;
+    if (spec.orgChart) return chartType.ORG;
+    if (spec.waterfallChart) return chartType.WATERFALL;
+    if (spec.treemapChart) return chartType.TREE_MAP;
+    if (spec.scorecardChart) return chartType.SCORECARD;
+    if (spec.histogramChart) return chartType.HISTOGRAM;
+
+    return null;
+  }
+
+  setPosition(anchorRowPos, anchorColPos, offsetX, offsetY) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "EmbeddedChartBuilder.setPosition");
+    if (nargs !== 4) matchThrow();
+
+    this.__apiChart.position.overlayPosition.anchorCell.rowIndex = anchorRowPos - 1;
+    this.__apiChart.position.overlayPosition.anchorCell.columnIndex = anchorColPos - 1;
+    this.__apiChart.position.overlayPosition.offsetXPixels = offsetX;
+    this.__apiChart.position.overlayPosition.offsetYPixels = offsetY;
+    return this;
+  }
+
+  setOption(option, value) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "EmbeddedChartBuilder.setOption");
+    if (nargs !== 2) matchThrow();
+
+    if (option === "title") {
+      this.__apiChart.spec.title = value;
+    } else {
+      // For other options, we might want to store them in a general options object if needed,
+      // but for now, we'll just focus on "title" as requested.
+      // SpreadsheetApp.EmbeddedChartBuilder.setOption(option, value)
+      if (!this.__apiChart.spec.basicChart.options) {
+        this.__apiChart.spec.basicChart.options = {};
+      }
+      this.__apiChart.spec.basicChart.options[option] = value;
+    }
+    return this;
+  }
+
+  build() {
+    const { nargs, matchThrow } = signatureArgs(arguments, "EmbeddedChartBuilder.build");
+    if (nargs !== 0) matchThrow();
+
+    // In a real GAS, build() returns an EmbeddedChart that is NOT yet inserted.
+    // Here we return the api object wrapped in a FakeEmbeddedChart if needed,
+    // or just the raw object that insertChart will use.
+    // Actually, gas.Sheet.insertChart expects an EmbeddedChart object.
+    return newFakeEmbeddedChart(this.__apiChart, this.__sheet);
+  }
+
+  toString() {
+    const hex = Math.floor(Math.random() * 0xffffffff).toString(16).padStart(8, "0");
+    return `com.google.apps.maestro.server.beans.trix.impl.ChartPropertyApiEmbeddedChartBuilder@${hex}`;
+  }
+}

package/src/services/spreadsheetapp/fakesheet.js

@@ -14,6 +14,8 @@ import { FakeTextFinder, newFakeTextFinder } from "./faketextfinder.js";
 import { newFakeNamedRange } from "./fakenamedrange.js";
 import { newFakeProtection } from "./fakeprotection.js";
 import { newFakeOverGridImage } from "./fakeovergridimage.js";
+import { newFakeEmbeddedChart } from "./fakeembeddedchart.js";
+import { newFakeEmbeddedChartBuilder } from "./fakeembeddedchartbuilder.js";
 
 import { XMLParser } from "fast-xml-parser";
 import { slogger } from "../../support/slogger.js";
@@ -34,10 +36,6 @@ export class FakeSheet {
     this.__parent = parent;
 
     const props = [
-      "getCharts",
-      "insertChart",
-      "removeChart",
-      "updateChart",
       // "getImages",
       "insertImage",
       "removeImage",
@@ -399,6 +397,63 @@ export class FakeSheet {
     return pivotTables;
   }
 
+  getCharts() {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.getCharts");
+    if (nargs !== 0) matchThrow();
+
+    const meta = this.getParent().__getMetaProps(
+      `sheets(charts,properties.sheetId)`
+    );
+    const sheetMeta = meta.sheets.find(
+      (s) => s.properties.sheetId === this.getSheetId()
+    );
+
+    return (sheetMeta?.charts || []).map((c) => newFakeEmbeddedChart(c, this));
+  }
+
+  insertChart(chart) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.insertChart");
+    if (nargs !== 1 || !is.object(chart)) matchThrow();
+
+    const request = {
+      addChart: {
+        chart: chart.__apiChart,
+      },
+    };
+    batchUpdate({ spreadsheet: this.getParent(), requests: [request] });
+    return this;
+  }
+
+  newChart() {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.newChart");
+    if (nargs !== 0) matchThrow();
+
+    return newFakeEmbeddedChartBuilder(this);
+  }
+
+  removeChart(chart) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.removeChart");
+    if (nargs !== 1 || !is.object(chart)) matchThrow();
+
+    chart.remove();
+    return this;
+  }
+
+  updateChart(chart) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "Sheet.updateChart");
+    if (nargs !== 1 || !is.object(chart)) matchThrow();
+
+    const request = {
+      updateEmbeddedObjectPosition: {
+        objectId: chart.getChartId(),
+        newPosition: chart.__apiChart.position,
+        fields: "*",
+      },
+    };
+    batchUpdate({ spreadsheet: this.getParent(), requests: [request] });
+    return this;
+  }
+
   getBandings() {
     const meta = this.getParent().__getMetaProps(
       `sheets(bandedRanges,properties.sheetId)`

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) };