@mcpher/gas-fakes 1.2.20 → 1.2.22

package/.clasp.json

@@ -0,0 +1,4 @@
+{
+  "scriptId": "",
+  "rootDir": "./src/"
+}

package/.claspignore

@@ -0,0 +1,6 @@
+# Ignore local development files
+run.js
+node_modules/
+package.json
+package-lock.json
+.gemini/

package/package.json

@@ -20,6 +20,7 @@
     "mime": "^4.0.7",
     "prompts": "^2.4.2",
     "sleep-synchronously": "^2.0.0",
+    "tape": "^5.9.0",
     "unzipper": "^0.12.3",
     "zod": "^3.25.76"
   },
@@ -32,7 +33,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "1.2.20",
+  "version": "1.2.22",
   "license": "MIT",
   "main": "main.js",
   "description": "A proof of concept implementation of Apps Script Environment on Node",

package/run.js

@@ -0,0 +1,35 @@
+import fs from 'fs';
+import path from 'path';
+import vm from 'vm';
+
+// Import gas-fakes to initialize the environment
+import '@mcpher/gas-fakes';
+
+// Create a sandboxed context
+const context = vm.createContext({
+  ScriptApp: global.ScriptApp,
+  console: console,
+  // Add other GAS globals you need here (e.g., DocumentApp, SpreadsheetApp)
+});
+
+// Read the user's script file
+const scriptPath = path.resolve('src/Code.js');
+const scriptCode = fs.readFileSync(scriptPath, 'utf8');
+
+// Run the user's script in the sandbox to define the functions
+vm.runInContext(scriptCode, context);
+
+// Define and run the calling logic to execute a function from the script
+const callingCode = `
+// 1. Enable sandbox mode for safety
+ScriptApp.__behavior.sandBoxMode = true;
+
+// 2. Call the specific function from your Code.js file
+// myFunction();
+
+// 3. Clean up the gas-fakes environment
+ScriptApp.__behavior.trash();
+`;
+
+// vm.runInContext(callingCode, context);
+console.log("Project initialized. Edit run.js to execute a function.");

package/src/Code.js

@@ -0,0 +1,3 @@
+function myFunction() {
+  console.log('Hello from Google Apps Script!');
+}

package/src/appsscript.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {},
+  "exceptionLogging": "STACKDRIVER",
+  "runtimeVersion": "V8"
+}

package/src/services/advforms/fakeadvforms.js

@@ -42,7 +42,8 @@ class FakeAdvForms {
       "newFormInfo": [
         "title",
         "documentTitle",
-        "description"
+        "description",
+        "state"
       ],
       "newUpdateSettingsRequest": [
         "settings",

package/src/services/advforms/fakeadvformsform.js

@@ -4,6 +4,7 @@ import { signatureArgs, ssError, gError } from '../../support/helpers.js';
 
 import { Proxies } from '../../support/proxies.js';
 import { Utils } from '../../support/utils.js';
+import { newFakeResponses } from './fakeresponses.js';
 const { is } = Utils
 
 export const newFakeAdvFormsForm = (...args) => Proxies.guard(new FakeAdvFormsForm(...args))
@@ -13,6 +14,17 @@ class FakeAdvFormsForm extends FakeAdvResource {
     super(mainService, 'forms', Syncit.fxForms);
     this.forms = mainService;
     this.__fakeObjectType = 'Forms.Forms';
+    this.__responses = null;
+  }
+
+  /**
+   * @returns {import('./fakeresponses.js').FakeResponses}
+   */
+  get Responses() {
+    if (!this.__responses) {
+      this.__responses = newFakeResponses(this);
+    }
+    return this.__responses;
   }
 
   /**

package/src/services/advforms/fakeresponses.js

@@ -0,0 +1,30 @@
+import { Proxies } from '../../support/proxies.js';
+import { Utils } from '../../support/utils.js';
+
+export const newFakeResponses = (...args) => {
+  return Proxies.guard(new FakeResponses(...args));
+};
+
+/**
+ * @class FakeResponses
+ * @see https://developers.google.com/forms/api/reference/rest/v1/forms.responses
+ */
+export class FakeResponses {
+  constructor(mainService) {
+    this.forms = mainService;
+    this.__fakeObjectType = 'Forms.Responses';
+  }
+
+  /**
+   * Lists the responses of a form.
+   * @param {string} formId The form's ID.
+   * @returns {{responses: object[]}} A list of responses.
+   */
+  list(formId) {
+    // this.forms is the FakeAdvFormsForm instance, which has the _call method
+    // from FakeAdvResource to interact with the syncit data source.
+    // We use subProp to specify the nested 'responses' object, following the library's pattern.
+    const { data } = this.forms._call('list', { formId }, null, 'responses');
+    return data || { responses: [] };
+  }
+}

package/src/services/formapp/fakecheckboxgriditem.js

@@ -0,0 +1,105 @@
+import { Proxies } from '../../support/proxies.js';
+import { FakeFormItem } from './fakeformitem.js';
+import { registerFormItem } from './formitemregistry.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
+import { ItemType } from '../enums/formsenums.js';
+
+export const newFakeCheckboxGridItem = (...args) => {
+  return Proxies.guard(new FakeCheckboxGridItem(...args));
+};
+
+/**
+ * @class FakeCheckboxGridItem
+ * A fake for the CheckboxGridItem class in Apps Script.
+ * @see https://developers.google.com/apps-script/reference/forms/checkbox-grid-item
+ */
+export class FakeCheckboxGridItem extends FakeFormItem {
+  constructor(form, itemId) {
+    super(form, itemId);
+  }
+
+  /**
+   * Gets the values for every column in the grid.
+   * @returns {string[]} an array of column values
+   */
+  getColumns() {
+    const choiceQuestion = this.__resource.questionGroupItem?.grid?.columns;
+    if (!choiceQuestion || !choiceQuestion.options) {
+      return [];
+    }
+    return choiceQuestion.options.map(option => option.value);
+  }
+
+  /**
+   * Gets the values for every row in the grid.
+   * @returns {string[]} an array of row values
+   */
+  getRows() {
+    const questions = this.__resource.questionGroupItem?.questions;
+    if (!questions) {
+      return [];
+    }
+    return questions.map(question => question.rowQuestion?.title || null).filter(f => f);
+  }
+
+  /**
+   * Sets the columns of the grid based on an array of values.
+   * @param {string[]} columns an array of column values
+   * @returns {FakeCheckboxGridItem} this item, for chaining
+   */
+  setColumns(columns) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'CheckboxGridItem.setColumns');
+    if (nargs !== 1 || !Utils.is.array(columns) || !columns.every(Utils.is.string)) {
+      matchThrow('Invalid arguments: expected a string array.');
+    }
+    if (columns.length === 0) {
+      throw new Error('The array of columns cannot be empty.');
+    }
+
+    const updatedResource = JSON.parse(JSON.stringify(this.__resource));
+    updatedResource.questionGroupItem.grid.columns.options = columns.map(c => ({ value: c }));
+
+    const updateRequest = Forms.newRequest().setUpdateItem({
+      item: updatedResource,
+      location: { index: this.getIndex() },
+      updateMask: 'questionGroupItem.grid.columns.options',
+    });
+
+    return this.__update(updateRequest);
+  }
+
+  /**
+   * Sets the rows of the grid based on an array of values.
+   * @param {string[]} rows an array of row values
+   * @returns {FakeCheckboxGridItem} this item, for chaining
+   */
+  setRows(rows) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'CheckboxGridItem.setRows');
+    if (nargs !== 1 || !Utils.is.array(rows) || !rows.every(Utils.is.string)) {
+      matchThrow('Invalid arguments: expected a string array.');
+    }
+    if (rows.length === 0) {
+      throw new Error('The array of rows cannot be empty.');
+    }
+
+    const updatedResource = JSON.parse(JSON.stringify(this.__resource));
+    updatedResource.questionGroupItem.questions = rows.map(r => ({
+      rowQuestion: { title: r },
+    }));
+
+    const updateRequest = Forms.newRequest().setUpdateItem({
+      item: updatedResource,
+      location: { index: this.getIndex() },
+      updateMask: 'questionGroupItem.questions',
+    });
+
+    return this.__update(updateRequest);
+  }
+
+  toString() {
+    return 'CheckboxGridItem';
+  }
+}
+
+registerFormItem(ItemType.CHECKBOX_GRID, newFakeCheckboxGridItem);

package/src/services/formapp/fakecheckboxitem.js

@@ -1,5 +1,5 @@
 import { Proxies } from '../../support/proxies.js';
-import { FakeFormItem } from './fakeformitem.js';
+import { FakeChoiceItem } from './fakechoiceitem.js';
 import { signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
 const { is } = Utils;
@@ -16,7 +16,7 @@ export const newFakeCheckboxItem = (...args) => {
  * A fake for the CheckboxItem class in Apps Script.
  * @see https://developers.google.com/apps-script/reference/forms/checkbox-item
  */
-export class FakeCheckboxItem extends FakeFormItem {
+export class FakeCheckboxItem extends FakeChoiceItem {
   /**
    * @param {import('./fakeform.js').FakeForm} form The parent form.
    * @param {string} itemId The ID of the item.
@@ -25,114 +25,6 @@ export class FakeCheckboxItem extends FakeFormItem {
     super(form, itemId);
   }
 
-  /**
-   * Creates a new choice for this item.
-   * @param {string} value The value of the choice.
-   * @param {boolean} [isCorrect] Whether the choice is correct.
-   * @returns {import('./fakechoice.js').FakeChoice} The new choice.
-   */
-  createChoice(value, isCorrect) {
-    const { nargs, matchThrow } = signatureArgs(arguments, 'CheckboxItem.createChoice');
-    if (nargs < 1 || nargs > 2 || !is.string(value) || (nargs === 2 && !is.boolean(isCorrect))) {
-      matchThrow('Invalid arguments');
-    }
-    // For now, navigation is not supported.
-    return newFakeChoice(value, isCorrect || false, null, null);
-  }
-
-  /**
-   * Gets the choices for this item.
-   * @returns {import('./fakechoice.js').FakeChoice[]} An array of Choice objects.
-   */
-  getChoices() {
-    const choiceQuestion = this.__resource.questionItem?.question?.choiceQuestion;
-    if (!choiceQuestion || !choiceQuestion.options) {
-      return [];
-    }
-    return choiceQuestion.options.map(option => {
-      return newFakeChoice(option.value, false, null, null);
-    });
-  }
-
-  /**
-   * Sets the choices for this item.
-   * @param {import('./fakechoice.js').FakeChoice[]} choices An array of Choice objects.
-   * @returns {FakeCheckboxItem} This item, for chaining.
-   */
-  setChoices(choices) {
-    const { nargs, matchThrow } = signatureArgs(arguments, 'CheckboxItem.setChoices');
-    if (nargs !== 1 || !is.array(choices) || !choices.every(c => c.toString() === 'Choice')) {
-      matchThrow('Invalid arguments: expected an array of Choice objects.');
-    }
-
-    const newOptions = choices.map(choice => Forms.newOption().setValue(choice.getValue()));
-    const currentIndex = this._getCurrentIndex();
-
-    const updateRequest = Forms.newRequest().setUpdateItem({
-      item: {
-        itemId: this.getId(),
-        questionItem: {
-          question: {
-            choiceQuestion: {
-              options: newOptions,
-            },
-          },
-        },
-      },
-      location: {
-        index: currentIndex,
-      },
-      updateMask: 'questionItem.question.choiceQuestion.options',
-    });
-
-    const batchRequest = Forms.newBatchUpdateFormRequest().setRequests([updateRequest]);
-    Forms.Form.batchUpdate(batchRequest, this.__form.getId());
-
-    return this;
-  }
-
-  /**
-   * Sets whether this item is required.
-   * @param {boolean} enabled Whether the item is required.
-   * @returns {FakeCheckboxItem} This item, for chaining.
-   */
-  setRequired(enabled) {
-    const { nargs, matchThrow } = signatureArgs(arguments, 'CheckboxItem.setRequired');
-    if (nargs !== 1 || !is.boolean(enabled)) {
-      matchThrow('Invalid arguments: expected a boolean.');
-    }
-
-    const currentIndex = this._getCurrentIndex();
-
-    const updateRequest = Forms.newRequest().setUpdateItem({
-      item: {
-        itemId: this.getId(),
-        questionItem: {
-          question: {
-            required: enabled,
-          },
-        },
-      },
-      location: {
-        index: currentIndex,
-      },
-      updateMask: 'questionItem.question.required',
-    });
-
-    const batchRequest = Forms.newBatchUpdateFormRequest().setRequests([updateRequest]);
-    Forms.Form.batchUpdate(batchRequest, this.__form.getId());
-
-    return this;
-  }
-
-  /**
-   * Returns whether this item is required.
-   * @returns {boolean} True if the item is required, false otherwise.
-   */
-  isRequired() {
-    return this.__resource.questionItem?.question?.required || false;
-  }
-
   toString() {
     return 'CheckboxItem';
   }

package/src/services/formapp/fakechoice.js

@@ -1,4 +1,6 @@
 import { Proxies } from '../../support/proxies.js';
+import { PageNavigationType, ItemType } from '../enums/formsenums.js';
+import { newFakePageBreakItem } from './fakepagebreakitem.js';
 
 export const newFakeChoice = (...args) => {
   return Proxies.guard(new FakeChoice(...args));
@@ -10,33 +12,48 @@ export const newFakeChoice = (...args) => {
  * @see https://developers.google.com/apps-script/reference/forms/choice
  */
 export class FakeChoice {
-  /**
-   * @param {string} value The value of the choice.
-   * @param {boolean} isCorrect Whether the choice is correct.
-   * @param {import('./pagebreakitem.js').FakePageBreakItem} page The page to navigate to.
-   * @param {FormApp.PageNavigationType} navigationType The navigation type.
-   */
-  constructor(value, isCorrect, page, navigationType) {
+  constructor(value, navType, pageId, form, parentItemType) {
     this.__value = value;
-    this.__isCorrect = isCorrect;
-    this.__page = page;
-    this.__navigationType = navigationType;
-  }
-
-  getGotoPage() {
-    return this.__page;
+    this.__navType = navType;
+    this.__pageId = pageId;
+    this.__form = form;
+    this.__parentItemType = parentItemType;
   }
 
-  getIsCorrect() {
-    return this.__isCorrect;
+  getValue() {
+    return this.__value;
   }
 
+  /**
+   * Gets the page navigation type for this choice.
+   * @returns {import('../enums/formsenums.js').PageNavigationType | null} The page navigation type, or null if no navigation is set.
+   */
   getPageNavigationType() {
-    return this.__navigationType;
+    if (this.__navType) {
+      // The navType is stored as a string like 'goToPage' or 'CONTINUE'.
+      // We need to return the corresponding enum value.
+      const navEnum = PageNavigationType[this.__navType.toUpperCase()];
+      return navEnum || null;
+    }
+    return null;
   }
 
-  getValue() {
-    return this.__value;
+  /**
+   * Gets the page-break item that this choice navigates to.
+   * @returns {import('./fakepagebreakitem.js').FakePageBreakItem | null} The page-break item, or null if the choice does not navigate to a page.
+   */
+  getGoToPage() {
+    // Per live documentation, this method only applies to choices from a MultipleChoiceItem.
+    if (this.__parentItemType !== ItemType.MULTIPLE_CHOICE) {
+      throw new TypeError('getGoToPage is not a function');
+    }
+
+    if (this.__navType === 'GO_TO_PAGE' && this.__pageId && this.__form) {
+      // We need the form context to find the item by its ID.
+      const item = this.__form.getItemById(this.__pageId);
+      return item ? item.asPageBreakItem() : null;
+    }
+    return null;
   }
 
   toString() {

package/src/services/formapp/fakechoiceitem.js

@@ -0,0 +1,67 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeFormItem } from './fakeformitem.js';
+import { newFakeChoice } from './fakechoice.js';
+
+export const newFakeChoiceItem = (form, itemId) => {
+  return Proxies.guard(new FakeChoiceItem(form, itemId));
+};
+
+/**
+ * @class FakeChoiceItem
+ * A base class for items that have a list of choices, like MultipleChoiceItem and CheckboxItem.
+ * It is not a real Apps Script class but a helper for the fake environment.
+ */
+export class FakeChoiceItem extends newFakeFormItem().constructor {
+  constructor(form, itemId) {
+    super(form, itemId);
+  }
+
+  /**
+   * Creates a new choice.
+   * @param {string} value The text for the new choice.
+   * @returns {import('./fakechoice.js').FakeChoice} The new choice.
+   */
+  createChoice(value) {
+    return newFakeChoice(value);
+  }
+
+  /**
+   * Gets the choices for this item.
+   * @returns {import('./fakechoice.js').FakeChoice[]} An array of the choices.
+   */
+  getChoices() {
+    const choiceQuestion = this.__resource.questionItem.question.choiceQuestion;
+    return choiceQuestion.options.map(option => newFakeChoice(option.value));
+  }
+
+  /**
+   * Sets the choices for this item.
+   * @param {import('./fakechoice.js').FakeChoice[]} choices The new choices.
+   * @returns {FakeChoiceItem} The item, for chaining.
+   */
+  setChoices(choices) {
+    const choiceQuestion = this.__resource.questionItem.question.choiceQuestion;
+    choiceQuestion.options = choices.map(choice => ({ value: choice.getValue() }));
+
+    const updateRequest = Forms.newRequest().setUpdateItem({
+      item: {
+        itemId: this.getId(),
+        questionItem: {
+          question: {
+            choiceQuestion: choiceQuestion,
+          },
+        },
+      },
+      location: {
+        index: this.getIndex(),
+      },
+      updateMask: 'questionItem.question.choiceQuestion',
+    });
+
+    return this.__update(updateRequest);
+  }
+
+  toString() {
+    return 'FakeChoiceItem';
+  }
+}