@mcpher/gas-fakes 2.0.4 → 2.0.6

package/README.md

@@ -54,7 +54,20 @@ The optional `gasfakes.json` file holds various location and behavior parameters
 | properties | string | /tmp/gas-fakes/properties        | gas-fakes uses a local file to emulate apps script's PropertiesService. This is where it should put the files. You may want to put it somewhere other than /tmp to avoid accidental deletion, but don't put it in a place that'll get commited to public git repo                        |
 | scriptId   | string | from clasp, or some random value | If you have a clasp file, it'll pick up the scriptId from there. If not you can enter your scriptId manually, or just leave it to create a fake one. It's use for the moment is to return something useful from ScriptApp.getScriptId() and to partition the cache and properties stores |
 
+### Troubleshooting: Missing Environment Tags
 
+If you see a warning or error like `Project '...' lacks an 'environment' tag`, it means your Google Cloud Organization has a policy requiring projects to be designated with an environment tag (e.g., `Development`, `Production`).
+
+To resolve this, you need to bind an environment tag to your project. Replace `YOUR_ORG_ID` and `YOUR_PROJECT_ID` with your actual identifiers:
+
+```bash
+# Bind the 'Development' environment tag to your project
+gcloud resource-manager tags bindings create \
+  --tag-value=YOUR_ORG_ID/environment/Development \
+  --parent=//cloudresourcemanager.googleapis.com/projects/YOUR_PROJECT_ID
+```
+
+*Note: The tag key `environment` and the value `Development` must already exist at the organization level. If they don't, you (or your admin) will need to create them first using `gcloud resource-manager tags keys create` and `gcloud resource-manager tags values create`.*
 
 ### Cloud Logging Integration
 
@@ -168,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/package.json

@@ -33,7 +33,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "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",

package/src/cli/setup.js

@@ -483,7 +483,14 @@ export async function authenticateUser() {
     scopes += (extraScopes.startsWith(",") ? "" : ",") + extraScopes;
   }
   */
-  const scopes = Array.from(new Set([DEFAULT_SCOPES.split(",").concat(EXTRA_SCOPES.split(","))].filter(d => d))).join(",")
+  const scopes = Array.from(
+    new Set([
+      ...(DEFAULT_SCOPES || "").split(","),
+      ...(EXTRA_SCOPES || "").split(","),
+    ])
+  )
+    .filter((s) => s)
+    .join(",");
   const driveAccessFlag = "--enable-gdrive-access";
 
   console.log(`...requesting scopes ${scopes}`);
@@ -630,7 +637,7 @@ export async function authenticateUser() {
     // Service Account Lifecycle
     let existing_sa = false
     try {
-      execSync(`gcloud iam service-accounts describe "${sa_email}"`, { shell: true });
+      execSync(`gcloud iam service-accounts describe "${sa_email}"`, { stdio: "ignore", shell: true });
       existing_sa = true;
     } catch (error) {
       /* ignore */

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

@@ -4,6 +4,7 @@ import { registerFormItem } from './formitemregistry.js';
 import { signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
 import { ItemType } from '../enums/formsenums.js';
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeCheckboxGridItem = (...args) => {
   return Proxies.guard(new FakeCheckboxGridItem(...args));
@@ -19,6 +20,35 @@ export class FakeCheckboxGridItem extends FakeFormItem {
     super(form, itemId);
   }
 
+  /**
+   * Creates a new ItemResponse for this checkbox grid item.
+   * @param {string[][]} responses a two-dimensional array of responses, where each inner array represents the selected columns for a row
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(responses) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'CheckboxGridItem.createResponse');
+    if (nargs !== 1 || !Utils.is.array(responses) || !responses.every(Utils.is.array)) {
+      matchThrow('Invalid arguments: expected a two-dimensional string array.');
+    }
+
+    const questions = this.__resource.questionGroupItem?.questions || [];
+    if (responses.length !== questions.length) {
+      throw new Error(`The number of responses (${responses.length}) must match the number of rows (${questions.length}).`);
+    }
+
+    const answers = responses.map((rowResponses, index) => {
+      const questionId = questions[index].questionId;
+      return {
+        questionId,
+        textAnswers: {
+          answers: rowResponses.map(value => ({ value }))
+        }
+      };
+    });
+
+    return newFakeItemResponse(this, answers);
+  }
+
   /**
    * Gets the values for every column in the grid.
    * @returns {string[]} an array of column values

package/src/services/formapp/fakecheckboxitem.js

@@ -6,6 +6,7 @@ const { is } = Utils;
 import { registerFormItem } from './formitemregistry.js';
 import { newFakeChoice } from './fakechoice.js';
 import { ItemType } from '../enums/formsenums.js';
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeCheckboxItem = (...args) => {
   return Proxies.guard(new FakeCheckboxItem(...args));
@@ -25,6 +26,28 @@ export class FakeCheckboxItem extends FakeChoiceItem {
     super(form, itemId);
   }
 
+  /**
+   * Creates a new ItemResponse for this checkbox item.
+   * @param {string[]} responses the selected choices
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(responses) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'CheckboxItem.createResponse');
+    if (nargs !== 1 || !Utils.is.array(responses) || !responses.every(Utils.is.string)) {
+      matchThrow('Invalid arguments: expected a string array.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: responses.map(value => ({ value }))
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
   toString() {
     return 'CheckboxItem';
   }

package/src/services/formapp/fakedateitem.js

@@ -0,0 +1,67 @@
+import { Proxies } from '../../support/proxies.js';
+import { FakeFormItem } from './fakeformitem.js';
+import { registerFormItem } from './formitemregistry.js';
+import { ItemType } from '../enums/formsenums.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
+
+export const newFakeDateItem = (...args) => {
+  return Proxies.guard(new FakeDateItem(...args));
+};
+
+/**
+ * @class FakeDateItem
+ * @see https://developers.google.com/apps-script/reference/forms/date-item
+ */
+export class FakeDateItem extends FakeFormItem {
+  constructor(...args) {
+    super(...args);
+  }
+
+  /**
+   * Creates a new ItemResponse for this date item.
+   * @param {Date} date the date
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(date) {
+    const typeName = this.getType() === ItemType.DATETIME ? 'DateTimeItem' : 'DateItem';
+    const { nargs, matchThrow } = signatureArgs(arguments, `${typeName}.createResponse`);
+    if (nargs !== 1 || !is.date(date)) {
+      matchThrow('Invalid arguments: expected a Date object.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    
+    // Format date as YYYY-MM-DD or YYYY-MM-DDTHH:mm:ssZ for API?
+    // Actually, the Forms API expects text answers. 
+    // For DATE, it's "YYYY-MM-DD". For DATETIME, it's "YYYY-MM-DD HH:mm".
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    let value = `${year}-${month}-${day}`;
+    
+    if (this.getType() === ItemType.DATETIME) {
+      const hours = String(date.getHours()).padStart(2, '0');
+      const minutes = String(date.getMinutes()).padStart(2, '0');
+      value += ` ${hours}:${minutes}`;
+    }
+
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
+  toString() {
+    return this.getType() === ItemType.DATETIME ? 'DateTimeItem' : 'DateItem';
+  }
+}
+
+registerFormItem(ItemType.DATE, newFakeDateItem);
+registerFormItem(ItemType.DATETIME, newFakeDateItem);

package/src/services/formapp/fakedurationitem.js

@@ -0,0 +1,54 @@
+import { Proxies } from '../../support/proxies.js';
+import { FakeFormItem } from './fakeformitem.js';
+import { registerFormItem } from './formitemregistry.js';
+import { ItemType } from '../enums/formsenums.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
+
+export const newFakeDurationItem = (...args) => {
+  return Proxies.guard(new FakeDurationItem(...args));
+};
+
+/**
+ * @class FakeDurationItem
+ * @see https://developers.google.com/apps-script/reference/forms/duration-item
+ */
+export class FakeDurationItem extends FakeFormItem {
+  constructor(...args) {
+    super(...args);
+  }
+
+  /**
+   * Creates a new ItemResponse for this duration item.
+   * @param {number} hours the hours
+   * @param {number} minutes the minutes
+   * @param {number} seconds the seconds
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(hours, minutes, seconds) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'DurationItem.createResponse');
+    if (nargs !== 3 || !is.number(hours) || !is.number(minutes) || !is.number(seconds)) {
+      matchThrow('Invalid arguments: expected three numbers.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const value = `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
+  toString() {
+    return 'DurationItem';
+  }
+}
+
+registerFormItem(ItemType.DURATION, newFakeDurationItem);

package/src/services/formapp/fakeform.js

@@ -12,6 +12,9 @@ import { newFakeCheckboxItem } from './fakecheckboxitem.js';
 import { newFakeListItem } from './fakelistitem.js';
 import { newFakePageBreakItem } from './fakepagebreakitem.js';
 import { newFakeTextItem } from './faketextitem.js';
+import { newFakeDateItem } from './fakedateitem.js';
+import { newFakeTimeItem } from './faketimeitem.js';
+import { newFakeDurationItem } from './fakedurationitem.js';
 import { signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
 const { is } = Utils
@@ -261,6 +264,93 @@ export class FakeForm {
     return this.__addItem(itemResource, newFakeTextItem);
   }
 
+  /**
+   * Appends a new question item that allows the respondent to enter a paragraph of text.
+   * @returns {import('./faketextitem.js').FakeTextItem} The new paragraph text item.
+   */
+  addParagraphTextItem() {
+    const itemResource = {
+      questionItem: {
+        question: {
+          textQuestion: {
+            paragraph: true,
+          },
+        },
+      },
+    };
+    return this.__addItem(itemResource, newFakeTextItem);
+  }
+
+  /**
+   * Appends a new question item that allows the respondent to choose a date.
+   * @returns {import('./fakedateitem.js').FakeDateItem} The new date item.
+   */
+  addDateItem() {
+    const itemResource = {
+      questionItem: {
+        question: {
+          dateQuestion: {
+            includeYear: true,
+            includeTime: false,
+          },
+        },
+      },
+    };
+    return this.__addItem(itemResource, newFakeDateItem);
+  }
+
+  /**
+   * Appends a new question item that allows the respondent to choose a date and time.
+   * @returns {import('./fakedateitem.js').FakeDateItem} The new date-time item.
+   */
+  addDateTimeItem() {
+    const itemResource = {
+      questionItem: {
+        question: {
+          dateQuestion: {
+            includeYear: true,
+            includeTime: true,
+          },
+        },
+      },
+    };
+    return this.__addItem(itemResource, newFakeDateItem);
+  }
+
+  /**
+   * Appends a new question item that allows the respondent to choose a time.
+   * @returns {import('./faketimeitem.js').FakeTimeItem} The new time item.
+   */
+  addTimeItem() {
+    const itemResource = {
+      questionItem: {
+        question: {
+          timeQuestion: {
+            duration: false,
+          },
+        },
+      },
+    };
+    return this.__addItem(itemResource, newFakeTimeItem);
+  }
+
+  /**
+   * Appends a new question item that allows the respondent to choose a duration.
+   * @returns {import('./fakedurationitem.js').FakeDurationItem} The new duration item.
+   */
+  addDurationItem() {
+    const itemResource = {
+      questionItem: {
+        question: {
+          timeQuestion: {
+            duration: true,
+          },
+        },
+      },
+    };
+    return this.__addItem(itemResource, newFakeDurationItem);
+  }
+
   /**
    * Gets the ID of the form's response destination.
    * @returns {string | null} The destination ID, or null if no destination is set.

package/src/services/formapp/fakegriditem.js

@@ -4,6 +4,7 @@ import { registerFormItem } from './formitemregistry.js';
 import { signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
 import { ItemType } from '../enums/formsenums.js';
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeGridItem = (...args) => {
   return Proxies.guard(new FakeGridItem(...args));
@@ -19,6 +20,35 @@ export class FakeGridItem extends FakeFormItem {
     super(form, itemId);
   }
 
+  /**
+   * Creates a new ItemResponse for this grid item.
+   * @param {string[]} responses an array of responses, where each element represents the selected column for a row
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(responses) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'GridItem.createResponse');
+    if (nargs !== 1 || !Utils.is.array(responses) || !responses.every(Utils.is.string)) {
+      matchThrow('Invalid arguments: expected a string array.');
+    }
+
+    const questions = this.__resource.questionGroupItem?.questions || [];
+    if (responses.length !== questions.length) {
+      throw new Error(`The number of responses (${responses.length}) must match the number of rows (${questions.length}).`);
+    }
+
+    const answers = responses.map((rowResponse, index) => {
+      const questionId = questions[index].questionId;
+      return {
+        questionId,
+        textAnswers: {
+          answers: [{ value: rowResponse }]
+        }
+      };
+    });
+
+    return newFakeItemResponse(this, answers);
+  }
+
   /**
    * Gets the values for every column in the grid.
    * @returns {string[]} an array of column values
@@ -40,7 +70,7 @@ export class FakeGridItem extends FakeFormItem {
     if (!questions) {
       return [];
     }
-    return questions.map(question => question.rowQuestion?.title || null).filter(f=>f);
+    return questions.map(question => question.rowQuestion?.title || null).filter(f => f);
   }
 
   /**

package/src/services/formapp/fakeitemresponse.js

@@ -78,7 +78,11 @@ export class FakeItemResponse {
     );
 
     if (allTextAnswers.length === 0) {
-      return '';
+      return itemType === 'CHECKBOX' ? [] : '';
+    }
+
+    if (itemType === 'CHECKBOX') {
+      return allTextAnswers.map(a => a.value);
     }
 
     // For items like grids, there can be multiple answer values. The live script joins them with a comma.

package/src/services/formapp/fakelistitem.js

@@ -4,6 +4,9 @@ import { newFakeChoice } from './fakechoice.js';
 import { registerFormItem } from './formitemregistry.js';
 import { ItemType } from '../enums/formsenums.js';
 import { Utils } from '../../support/utils.js';
+import { signatureArgs } from '../../support/helpers.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeListItem = (...args) => {
   return Proxies.guard(new FakeListItem(...args));
@@ -18,6 +21,28 @@ export class FakeListItem extends FakeFormItem {
     super(...args);
   }
 
+  /**
+   * Creates a new ItemResponse for this list item.
+   * @param {string} response the selected choice
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(response) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.createResponse');
+    if (nargs !== 1 || !is.string(response)) {
+      matchThrow('Invalid arguments: expected a string.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value: response }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
   /**
    * Creates a new choice for this item.
    * @param {string} value The value for the new choice.

package/src/services/formapp/fakemultiplechoiceitem.js

@@ -2,6 +2,10 @@ import { Proxies } from '../../support/proxies.js';
 import { FakeChoiceItem } from './fakechoiceitem.js';
 import { registerFormItem } from './formitemregistry.js';
 import { ItemType } from '../enums/formsenums.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeMultipleChoiceItem = (form, itemId) => {
   return Proxies.guard(new FakeMultipleChoiceItem(form, itemId));
@@ -16,6 +20,29 @@ export class FakeMultipleChoiceItem extends FakeChoiceItem {
   constructor(form, itemId) {
     super(form, itemId);
   }
+
+  /**
+   * Creates a new ItemResponse for this multiple choice item.
+   * @param {string} response the selected choice
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(response) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'MultipleChoiceItem.createResponse');
+    if (nargs !== 1 || !is.string(response)) {
+      matchThrow('Invalid arguments: expected a string.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value: response }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
   toString() {
     return 'MultipleChoiceItem';
   }

package/src/services/formapp/fakescaleitem.js

@@ -5,6 +5,7 @@ import { ItemType } from '../enums/formsenums.js';
 import { signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
 const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeScaleItem = (...args) => {
   return Proxies.guard(new FakeScaleItem(...args));
@@ -20,6 +21,28 @@ export class FakeScaleItem extends FakeFormItem {
     super(form, itemId);
   }
 
+  /**
+   * Creates a new ItemResponse for this scale item.
+   * @param {number} response the selected value
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(response) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ScaleItem.createResponse');
+    if (nargs !== 1 || !is.number(response)) {
+      matchThrow('Invalid arguments: expected a number.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value: response.toString() }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
   /**
    * Gets the lower bound of the scale.
    * @returns {Integer} the lower bound

package/src/services/formapp/faketextitem.js

@@ -1,5 +1,11 @@
 import { Proxies } from '../../support/proxies.js';
 import { FakeFormItem } from './fakeformitem.js';
+import { registerFormItem } from './formitemregistry.js';
+import { ItemType } from '../enums/formsenums.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeTextItem = (...args) => {
   return Proxies.guard(new FakeTextItem(...args));
@@ -14,7 +20,34 @@ export class FakeTextItem extends FakeFormItem {
     super(...args);
   }
 
+  /**
+   * Creates a new ItemResponse for this text item.
+   * @param {string} response the response text
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(response) {
+    // Both TextItem and ParagraphTextItem have the same createResponse signature.
+    const typeName = this.getType() === ItemType.PARAGRAPH_TEXT ? 'ParagraphTextItem' : 'TextItem';
+    const { nargs, matchThrow } = signatureArgs(arguments, `${typeName}.createResponse`);
+    if (nargs !== 1 || !is.string(response)) {
+      matchThrow('Invalid arguments: expected a string.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value: response }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
   toString() {
-    return 'TextItem';
+    return this.getType() === ItemType.PARAGRAPH_TEXT ? 'ParagraphTextItem' : 'TextItem';
   }
-}
+}
+
+registerFormItem(ItemType.TEXT, newFakeTextItem);
+registerFormItem(ItemType.PARAGRAPH_TEXT, newFakeTextItem);

package/src/services/formapp/faketimeitem.js

@@ -0,0 +1,53 @@
+import { Proxies } from '../../support/proxies.js';
+import { FakeFormItem } from './fakeformitem.js';
+import { registerFormItem } from './formitemregistry.js';
+import { ItemType } from '../enums/formsenums.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
+
+export const newFakeTimeItem = (...args) => {
+  return Proxies.guard(new FakeTimeItem(...args));
+};
+
+/**
+ * @class FakeTimeItem
+ * @see https://developers.google.com/apps-script/reference/forms/time-item
+ */
+export class FakeTimeItem extends FakeFormItem {
+  constructor(...args) {
+    super(...args);
+  }
+
+  /**
+   * Creates a new ItemResponse for this time item.
+   * @param {number} hour the hour
+   * @param {number} minute the minute
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(hour, minute) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'TimeItem.createResponse');
+    if (nargs !== 2 || !is.number(hour) || !is.number(minute)) {
+      matchThrow('Invalid arguments: expected two numbers.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const value = `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
+
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
+  toString() {
+    return 'TimeItem';
+  }
+}
+
+registerFormItem(ItemType.TIME, newFakeTimeItem);

package/src/services/formapp/formitems.js

@@ -8,4 +8,8 @@ import './fakecheckboxgriditem.js';
 import './fakescaleitem.js';
 import './fakepagebreakitem.js';
 import './fakelistitem.js';
+import './faketextitem.js';
+import './fakedateitem.js';
+import './faketimeitem.js';
+import './fakedurationitem.js';
 // Add other item types here as they are implemented (e.g., './faketextitem.js')

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/support/auth.js

@@ -117,7 +117,7 @@ const setAuth = async (scopes = [], mcpLoading = false) => {
     // 2. if AUTH_TYPE is ADC, use ADC
     // 3. if AUTH_TYPE is not set, use DWD if saName is present, else ADC
     const saName = process.env.GOOGLE_SERVICE_ACCOUNT_NAME
-    const authType = process.env.AUTH_TYPE?.toLowerCase() || 'dwd'
+    const authType = process.env.AUTH_TYPE?.toLowerCase()
     const useDwd = authType === 'dwd' || (authType !== 'adc' && saName)
 
     if (!useDwd) {
@@ -127,6 +127,9 @@ const setAuth = async (scopes = [], mcpLoading = false) => {
       })
       _sourceClient = _authClient
     } else {
+      if (!saName) {
+        throw new Error("Domain-Wide Delegation (DWD) requested or inferred, but GOOGLE_SERVICE_ACCOUNT_NAME is not set in environment.");
+      }
       mayLog(`...using service account: ${saName}`)
       const targetPrincipal = `${saName}@${_projectId}.iam.gserviceaccount.com`
       mayLog(`...attempting to use service account: ${targetPrincipal}`)

package/src/support/sxauth.js

@@ -7,7 +7,7 @@
  */
 import got from 'got';
 import { Auth } from './auth.js';
-import { syncError, syncLog } from './workersync/synclogger.js';
+import { syncError, syncLog, syncWarn } from './workersync/synclogger.js';
 import { readFile, writeFile, mkdir } from 'fs/promises';
 import path from 'path'
 
@@ -140,7 +140,7 @@ export const sxInit = async ({ manifestPath, claspPath, settingsPath, cachePath,
   const allowedScopes = new Set(effectiveScopes)
   const missingScopes = scopes.filter(scope => !allowedScopes.has(scope))
   if (missingScopes.length > 0) {
-    syncError(`...these scopes were asked for but not granted: ${missingScopes.join(', ')}`)
+    syncWarn(`...these scopes were asked for but not granted: ${missingScopes.join(', ')}. Note: Operations may still succeed if the 'https://www.googleapis.com/auth/cloud-platform' scope was granted.`)
   }
   return {
     // these will be the scopes we're allowed to get