@mcpher/gas-fakes 1.2.26 → 1.2.28

package/src/services/calendarapp/fakecalendarapp.js

@@ -0,0 +1,147 @@
+import { Proxies } from '../../support/proxies.js';
+import * as CalendarEnums from '../enums/calendarenums.js';
+import { newFakeCalendar } from './fakecalendar.js';
+
+/**
+ * Creates a new FakeCalendarApp instance.
+ * @returns {FakeCalendarApp} The new instance.
+ */
+export const newFakeCalendarApp = () => {
+  return Proxies.guard(new FakeCalendarApp());
+};
+
+/**
+ * Placeholder for CalendarApp service.
+ * @see https://developers.google.com/apps-script/reference/calendar/calendar-app
+ */
+export class FakeCalendarApp {
+  constructor() {
+    // Attach enums
+    Object.assign(this, CalendarEnums);
+  }
+
+  createCalendar(name, options = {}) {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'createCalendar');
+    this.__checkUsage('write');
+    const resource = Calendar.Calendars.insert({ summary: name, ...options });
+    if (ScriptApp.__behavior.sandboxMode && resource.id) {
+      ScriptApp.__behavior.addCalendarId(resource.id);
+    }
+    return newFakeCalendar(resource.id, resource);
+  }
+
+  getCalendarById(id) {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getCalendarById');
+    this.__checkUsage('read');
+    this.__checkCalendarAccess(id);
+    const resource = Calendar.Calendars.get(id);
+    return newFakeCalendar(id, resource);
+  }
+
+  getDefaultCalendar() {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getDefaultCalendar');
+    return this.getCalendarById('primary');
+  }
+
+  getCalendarsByName(name) {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getCalendarsByName');
+    this.__checkUsage('read');
+    const list = Calendar.CalendarList.list();
+    return (list.items || [])
+      .filter(item => this.__isCalendarAccessible(item.id))
+      .filter(item => item.summary === name)
+      .map(item => newFakeCalendar(item.id, item));
+  }
+
+  getAllCalendars() {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getAllCalendars');
+    this.__checkUsage('read');
+    const list = Calendar.CalendarList.list();
+    return (list.items || [])
+      .filter(item => this.__isCalendarAccessible(item.id))
+      .map(item => newFakeCalendar(item.id, item));
+  }
+
+  getAllOwnedCalendars() {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getAllOwnedCalendars');
+    this.__checkUsage('read');
+    const list = Calendar.CalendarList.list();
+    return (list.items || [])
+      .filter(item => this.__isCalendarAccessible(item.id))
+      .filter(item => item.accessRole === 'owner')
+      .map(item => newFakeCalendar(item.id, item));
+  }
+
+  __isCalendarAccessible(calendarId) {
+    try {
+      this.__checkCalendarAccess(calendarId);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  __checkCalendarAccess(calendarId) {
+    const behavior = ScriptApp.__behavior;
+    if (!behavior.sandboxMode) return true;
+
+    // 1. Session check - calendars created in this session are always accessible
+    if (behavior.isKnownCalendar(calendarId)) return true;
+
+    // 2. Primary calendar is always accessible
+    if (calendarId === 'primary') return true;
+
+    // 3. Whitelist check
+    const settings = behavior.sandboxService.CalendarApp;
+    const whitelist = settings && settings.calendarWhitelist;
+
+    if (!whitelist) {
+      throw new Error(`Access to calendar ${calendarId} is denied. No calendar whitelist configured.`);
+    }
+
+    // Get calendar details to check name
+    const calendar = Calendar.Calendars.get(calendarId);
+    const calendarName = calendar.summary;
+
+    // Check if calendar name is in whitelist with read permission
+    const entry = whitelist.find(item => item.name === calendarName);
+    if (entry && entry.read) {
+      return true;
+    }
+
+    throw new Error(`Access to calendar "${calendarName}" (${calendarId}) is denied by sandbox rules`);
+  }
+
+  __checkUsage(type) {
+    const serviceName = 'CalendarApp';
+    const behavior = ScriptApp.__behavior;
+    if (behavior.sandboxMode) {
+      const settings = behavior.sandboxService[serviceName];
+      let limit = settings && settings.usageLimit;
+      if (limit) {
+        if (typeof limit === 'number') {
+          const total = (settings.usageCount.read || 0) + (settings.usageCount.write || 0) + (settings.usageCount.trash || 0);
+          if (total >= limit) {
+            throw new Error(`Calendar total usage limit of ${limit} exceeded`);
+          }
+          settings.incrementUsage(type);
+          return;
+        }
+
+        let specificLimit = limit[type];
+        if (specificLimit !== undefined) {
+          const current = settings.usageCount[type] || 0;
+          if (current >= specificLimit) {
+            throw new Error(`Calendar ${type} usage limit of ${specificLimit} exceeded`);
+          }
+          settings.incrementUsage(type);
+        }
+      }
+    }
+  }
+
+  // Common pattern in gas-fakes for internal use
+  __addAllowed(id) {
+    // Shared logic with other services to track created resources
+  }
+}

package/src/services/calendarapp/fakecalendarevent.js

@@ -0,0 +1,44 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeCalendarEvent = (...args) => {
+  return Proxies.guard(new FakeCalendarEvent(...args));
+};
+
+/**
+ * Represents a calendar event.
+ * @see https://developers.google.com/apps-script/reference/calendar/calendar-event
+ */
+export class FakeCalendarEvent {
+  /**
+   * @param {string} calendarId The calendar ID.
+   * @param {object} resource The underlying Event resource (Advanced).
+   */
+  constructor(calendarId, resource) {
+    this.__calendarId = calendarId;
+    this.__id = resource.id;
+    this.__iCalUID = resource.iCalUID;
+  }
+
+  get __resource() {
+    // Try to get by ID
+    try {
+        return Calendar.Events.get(this.__calendarId, this.__id);
+    } catch (e) {
+        // Fallback: search by iCalUID if main ID fails (though usually id is reliable for get)
+        // or if the event was deleted?
+        throw new Error(`Event with ID ${this.__id} not found in calendar ${this.__calendarId}`);
+    }
+  }
+
+  getId() {
+    return this.__resource.iCalUID || this.__resource.id;
+  }
+
+  getTitle() {
+    return this.__resource.summary || '';
+  }
+
+  toString() {
+    return 'CalendarEvent';
+  }
+}

package/src/services/calendarapp/fakecalendareventseries.js

@@ -0,0 +1,36 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeCalendarEventSeries = (...args) => {
+  return Proxies.guard(new FakeCalendarEventSeries(...args));
+};
+
+/**
+ * Represents a series of events (a recurring event).
+ * @see https://developers.google.com/apps-script/reference/calendar/calendar-event-series
+ */
+export class FakeCalendarEventSeries {
+  /**
+   * @param {string} calendarId The calendar ID.
+   * @param {object} resource The underlying Event resource (Advanced).
+   */
+  constructor(calendarId, resource) {
+    this.__calendarId = calendarId;
+    this.__id = resource.id;
+  }
+
+  get __resource() {
+    try {
+        return Calendar.Events.get(this.__calendarId, this.__id);
+    } catch (e) {
+        throw new Error(`Event Series with ID ${this.__id} not found in calendar ${this.__calendarId}`);
+    }
+  }
+
+  getId() {
+    return this.__resource.iCalUID || this.__resource.id;
+  }
+
+  toString() {
+    return 'CalendarEventSeries';
+  }
+}

package/src/services/calendarapp/fakeeventrecurrence.js

@@ -0,0 +1,19 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeEventRecurrence = (...args) => {
+  return Proxies.guard(new FakeEventRecurrence(...args));
+};
+
+/**
+ * Represents the recurrence settings for an event series.
+ * @see https://developers.google.com/apps-script/reference/calendar/event-recurrence
+ */
+export class FakeEventRecurrence {
+  constructor() {
+    // TODO: Implement recurrence rules storage
+  }
+
+  toString() {
+    return 'EventRecurrence';
+  }
+}

package/src/services/enums/calendarenums.js

@@ -0,0 +1,85 @@
+import { newFakeGasenum} from "@mcpher/fake-gasenum";
+export const Color = newFakeGasenum([
+  "BLUE",
+  "BROWN",
+  "CHARCOAL",
+  "CHESTNUT",
+  "GRAY",
+  "GREEN",
+  "INDIGO",
+  "LIME",
+  "MUSTARD",
+  "OLIVE",
+  "ORANGE",
+  "PINK",
+  "PLUM",
+  "PURPLE",
+  "RED",
+  "RED_ORANGE",
+  "SEA_BLUE",
+  "SLATE",
+  "TEAL",
+  "TURQOISE",
+  "YELLOW"
+])
+export const EventColor = newFakeGasenum([
+  "BLUE",
+  "CYAN",
+  "GRAY",
+  "GREEN",
+  "MAUVE",
+  "ORANGE",
+  "PALE_BLUE",
+  "PALE_GREEN",
+  "PALE_RED",
+  "RED",
+  "YELLOW"
+])
+export const EventTransparency = newFakeGasenum([
+  "OPAQUE",
+  "TRANSPARENT"
+])
+export const EventType = newFakeGasenum([
+  "DEFAULT",
+  "BIRTHDAY",
+  "FOCUS_TIME",
+  "FROM_GMAIL",
+  "OUT_OF_OFFICE",
+  "WORKING_LOCATION"
+])
+export const GuestStatus = newFakeGasenum([
+  "INVITED",
+  "MAYBE",
+  "NO",
+  "OWNER",
+  "YES"
+])
+export const Month = newFakeGasenum([
+  "JANUARY",
+  "FEBRUARY",
+  "MARCH",
+  "APRIL",
+  "MAY",
+  "JUNE",
+  "JULY",
+  "AUGUST",
+  "SEPTEMBER",
+  "OCTOBER",
+  "NOVEMBER",
+  "DECEMBER"
+])
+export const Visibility = newFakeGasenum([
+  "CONFIDENTIAL",
+  "DEFAULT",
+  "PRIVATE",
+  "PUBLIC"
+])
+export const Weekday = newFakeGasenum([
+  "SUNDAY",
+  "MONDAY",
+  "TUESDAY",
+  "WEDNESDAY",
+  "THURSDAY",
+  "FRIDAY",
+  "SATURDAY"
+])

package/src/services/enums/slidesenums.js

@@ -1,4 +1,4 @@
-import { newFakeGasenum} from "@mcpher/fake-gasenum";
+import { newFakeGasenum } from "@mcpher/fake-gasenum";
 
 export const AlignmentPosition = newFakeGasenum([
   "CENTER",

package/src/services/formapp/fakechoiceitem.js

@@ -45,7 +45,7 @@ export class FakeChoiceItem extends newFakeFormItem().constructor {
 
     const updateRequest = Forms.newRequest().setUpdateItem({
       item: {
-        itemId: this.getId(),
+        itemId: this.__itemId,
         questionItem: {
           question: {
             choiceQuestion: choiceQuestion,

package/src/services/formapp/fakeform.js

@@ -13,7 +13,7 @@ import { newFakeListItem } from './fakelistitem.js';
 import { newFakePageBreakItem } from './fakepagebreakitem.js';
 import { newFakeTextItem } from './faketextitem.js';
 import { signatureArgs } from '../../support/helpers.js';
-import {Utils} from '../../support/utils.js';
+import { Utils } from '../../support/utils.js';
 const { is } = Utils
 export const newFakeForm = (...args) => {
   return Proxies.guard(new FakeForm(...args));
@@ -53,7 +53,7 @@ export class FakeForm {
     return this;
   }
 
-    
+
   saveAndClose() {
     // this is a no-op in fake environment since it is stateless
   }
@@ -298,6 +298,7 @@ export class FakeForm {
     if (!this.__resource.items) {
       return null;
     }
+    const hexId = Utils.toHex(id);
     const isKnownItem = (id, item) => {
       if (item.itemId === id) return true;
       if (item.questionItem?.question?.questionId === id) return true;
@@ -307,7 +308,7 @@ export class FakeForm {
       return found
     }
 
-    const itemResource = this.__resource.items.find((item) => isKnownItem(id, item));
+    const itemResource = this.__resource.items.find((item) => isKnownItem(hexId, item));
 
     if (!itemResource) {
       return null;

package/src/services/formapp/fakeformitem.js

@@ -114,8 +114,7 @@ export class FakeFormItem {
   }
 
   getId() {
-    // Live Apps Script returns IDs as decimal numbers, not the hex strings from the API.
-    return parseInt(this.__itemId, 16); // Convert to decimal
+    return Utils.fromHex(this.__itemId);
   }
 
   getIndex() {

package/src/services/formapp/fakeformresponse.js

@@ -1,5 +1,6 @@
 import { Proxies } from '../../support/proxies.js';
 import { newFakeItemResponse } from './fakeitemresponse.js';
+import { Utils } from '../../support/utils.js';
 
 export const newFakeFormResponse = (...args) => {
   return Proxies.guard(new FakeFormResponse(...args));
@@ -33,7 +34,7 @@ export class FakeFormResponse {
    * @returns {number} the unique hex ID converted to a decimal number
    */
   getId() {
-    return parseInt(this.__resource.responseId, 16);
+    return Utils.fromHex(this.__resource.responseId);
   }
 
   /**
@@ -59,7 +60,7 @@ export class FakeFormResponse {
     const groupedAnswers = new Map();
 
     for (const [questionId, answer] of Object.entries(this.__resource.answers)) {
-      const item = this.__form.getItemById(questionId);
+      const item = this.__form.getItemById(Utils.fromHex(questionId));
 
       if (item) {
         const itemId = item.getId(); // Use the unique item ID as the key.

package/src/services/formapp/fakelistitem.js

@@ -3,6 +3,7 @@ import { FakeFormItem } from './fakeformitem.js';
 import { newFakeChoice } from './fakechoice.js';
 import { registerFormItem } from './formitemregistry.js';
 import { ItemType } from '../enums/formsenums.js';
+import { Utils } from '../../support/utils.js';
 
 export const newFakeListItem = (...args) => {
   return Proxies.guard(new FakeListItem(...args));
@@ -56,7 +57,7 @@ export class FakeListItem extends FakeFormItem {
       // Translate from API format back to Apps Script format.
       if (option.goToSectionId) {
         navType = 'GO_TO_PAGE';
-        pageId = option.goToSectionId;
+        pageId = Utils.fromHex(option.goToSectionId);
       } else if (option.goToAction) {
         switch (option.goToAction) {
           case 'NEXT_SECTION': navType = 'CONTINUE'; break;
@@ -85,7 +86,7 @@ export class FakeListItem extends FakeFormItem {
           case 'GO_TO_PAGE':
             // For navigating to a specific page, you ONLY set the goToSectionId.
             // The pageId is the itemId of the PageBreakItem.
-            option.goToSectionId = choice.__pageId;
+            option.goToSectionId = Utils.toHex(choice.__pageId);
             break;
           case 'CONTINUE':
             option.goToAction = 'NEXT_SECTION';

package/src/services/scriptapp/behavior.js

@@ -17,6 +17,7 @@ const serviceModel = {
   methodWhitelist: null,
   emailWhitelist: null,
   labelWhitelist: null,
+  calendarWhitelist: null,
   usageLimit: null,
   usageCount: 0
 }
@@ -169,6 +170,17 @@ class FakeSandboxService {
     return this.__state.labelWhitelist
   }
 
+  set calendarWhitelist(value) {
+    if (!is.null(value)) {
+      checkArgs(value, "array")
+      // We expect objects like { name: 'calendar-name', read?: boolean, write?: boolean, delete?: boolean }
+    }
+    this.__state.calendarWhitelist = value
+  }
+  get calendarWhitelist() {
+    return this.__state.calendarWhitelist
+  }
+
   set usageLimit(value) {
     if (!is.null(value)) {
       // expect object with read, write, trash keys optionally
@@ -211,6 +223,11 @@ class FakeSandboxService {
     return this.__state.usageCount[type];
   }
 
+  resetUsageCount() {
+    this.__state.usageCount = { read: 0, write: 0, trash: 0, send: 0 };
+    return this;
+  }
+
   set enabled(value) {
     this.__state.enabled = checkArgs(value)
   }
@@ -236,6 +253,7 @@ class FakeBehavior {
     // key is the file id
     this.__createdIds = new Set();
     this.__createdGmailIds = new Set();
+    this.__createdCalendarIds = new Set();
     // in sandbox mode we only allow access to files created in this instance
     // this is to emulate the behavior of a drive.file scope
     this.__sandboxMode = false;
@@ -347,6 +365,18 @@ class FakeBehavior {
     }
     return id
   }
+  addCalendarId(id) {
+    if (this.sandboxMode) {
+      if (!is.nonEmptyString(id)) {
+        throw new Error(`Invalid sandbox id parameter (${id}) - must be a non-empty string`);
+      }
+      if (!this.isKnownCalendar(id)) {
+        slogger.log(`...adding calendar id ${id} to sandbox allowed list`);
+        this.__createdCalendarIds.add(id);
+      }
+    }
+    return id
+  }
   isAccessible(id, serviceName, accessType = 'read') {
     if (this.sandboxMode && !is.nonEmptyString(id)) {
       throw new Error(`Invalid sandbox id parameter (${id}) - must be a non-empty string`);
@@ -510,7 +540,29 @@ class FakeBehavior {
       slogger.log('...skipping cleaning up sandbox files (Gmail)');
     }
 
-    slogger.log(`...trashed ${trashed.length} sandboxed files and ${trashedGmail.length} gmail items`);
+    // Clean up Calendar artifacts
+    let trashedCalendars = [];
+    const calendarSettings = this.sandboxService.CalendarApp;
+    const calendarCleanup = calendarSettings && calendarSettings.cleanup;
+
+    if (calendarCleanup) {
+      trashedCalendars = Array.from(this.__createdCalendarIds).reduce((acc, id) => {
+        try {
+          // Delete calendar
+          Calendar.Calendars.delete(id);
+          slogger.log(`...deleted calendar ${id}`);
+          acc.push(id);
+        } catch (e) {
+          slogger.log(`...failed to delete calendar ${id}: ${e.message}`);
+        }
+        return acc;
+      }, []);
+      this.__createdCalendarIds.clear();
+    } else {
+      slogger.log('...skipping cleaning up sandbox calendars');
+    }
+
+    slogger.log(`...trashed ${trashed.length} sandboxed files, ${trashedGmail.length} gmail items, and ${trashedCalendars.length} calendars`);
     return trashed;
   }
   isKnown(id) {
@@ -519,4 +571,7 @@ class FakeBehavior {
   isKnownGmail(id) {
     return this.__createdGmailIds.has(id);
   }
+  isKnownCalendar(id) {
+    return this.__createdCalendarIds.has(id);
+  }
 }

package/src/services/slidesapp/fakeaffinetransform.js

@@ -0,0 +1,55 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeAffineTransformBuilder } from './fakeaffinetransformbuilder.js';
+
+export const newFakeAffineTransform = (...args) => {
+  return Proxies.guard(new FakeAffineTransform(...args));
+};
+
+export class FakeAffineTransform {
+  constructor(scaleX, shearY, shearX, scaleY, translateX, translateY) {
+    this.__scaleX = scaleX;
+    this.__shearY = shearY;
+    this.__shearX = shearX;
+    this.__scaleY = scaleY;
+    this.__translateX = translateX;
+    this.__translateY = translateY;
+  }
+
+  getScaleX() {
+    return this.__scaleX;
+  }
+
+  getScaleY() {
+    return this.__scaleY;
+  }
+
+  getShearX() {
+    return this.__shearX;
+  }
+
+  getShearY() {
+    return this.__shearY;
+  }
+
+  getTranslateX() {
+    return this.__translateX;
+  }
+
+  getTranslateY() {
+    return this.__translateY;
+  }
+
+  toBuilder() {
+    return newFakeAffineTransformBuilder()
+      .setScaleX(this.__scaleX)
+      .setShearY(this.__shearY)
+      .setShearX(this.__shearX)
+      .setScaleY(this.__scaleY)
+      .setTranslateX(this.__translateX)
+      .setTranslateY(this.__translateY);
+  }
+
+  toString() {
+    return 'AffineTransform';
+  }
+}

package/src/services/slidesapp/fakeaffinetransformbuilder.js

@@ -0,0 +1,64 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeAffineTransform } from './fakeaffinetransform.js';
+
+export const newFakeAffineTransformBuilder = (...args) => {
+  return Proxies.guard(new FakeAffineTransformBuilder(...args));
+};
+
+export class FakeAffineTransformBuilder {
+  constructor() {
+    // Defaults? Documentation doesn't explicitly specify, but identity matrix is reasonable.
+    // scaleX=1, scaleY=1, others 0.
+    this.__scaleX = 1;
+    this.__shearY = 0;
+    this.__shearX = 0;
+    this.__scaleY = 1;
+    this.__translateX = 0;
+    this.__translateY = 0;
+  }
+
+  build() {
+    return newFakeAffineTransform(
+      this.__scaleX,
+      this.__shearY,
+      this.__shearX,
+      this.__scaleY,
+      this.__translateX,
+      this.__translateY
+    );
+  }
+
+  setScaleX(scaleX) {
+    this.__scaleX = scaleX;
+    return this;
+  }
+
+  setScaleY(scaleY) {
+    this.__scaleY = scaleY;
+    return this;
+  }
+
+  setShearX(shearX) {
+    this.__shearX = shearX;
+    return this;
+  }
+
+  setShearY(shearY) {
+    this.__shearY = shearY;
+    return this;
+  }
+
+  setTranslateX(translateX) {
+    this.__translateX = translateX;
+    return this;
+  }
+
+  setTranslateY(translateY) {
+    this.__translateY = translateY;
+    return this;
+  }
+
+  toString() {
+    return 'AffineTransformBuilder';
+  }
+}