@mcpher/gas-fakes 1.2.28 → 1.2.30

package/package.json

@@ -3,7 +3,7 @@
     "node": ">=20.11.0"
   },
   "dependencies": {
-    "@mcpher/fake-gasenum": "^1.0.2",
+    "@mcpher/fake-gasenum": "^1.0.6",
     "@mcpher/gas-flex-cache": "^1.1.3",
     "@modelcontextprotocol/sdk": "^1.20.2",
     "@sindresorhus/is": "^7.0.1",
@@ -34,7 +34,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "1.2.28",
+  "version": "1.2.30",
   "license": "MIT",
   "main": "main.js",
   "description": "A proof of concept implementation of Apps Script Environment on Node",

package/src/services/calendarapp/fakecalendar.js

@@ -1,7 +1,7 @@
 import { Proxies } from '../../support/proxies.js';
 import { newFakeCalendarEvent } from './fakecalendarevent.js';
 import { newFakeCalendarEventSeries } from './fakecalendareventseries.js';
-
+import { Utils } from '../../support/utils.js';
 export const newFakeCalendar = (...args) => {
   return Proxies.guard(new FakeCalendar(...args));
 };
@@ -16,7 +16,9 @@ export class FakeCalendar {
    * @param {object} resource The underlying Calendar resource (Advanced).
    */
   constructor(id, resource) {
-    this.__id = id;
+    // If a resource is provided, use its canonical ID (e.g. email) instead of the lookup ID (e.g. 'primary')
+    // This matches GAS behavior where getId() returns the email even if retrieved via 'primary'
+    this.__id = (resource && resource.id) ? resource.id : id;
   }
 
   /**
@@ -81,10 +83,13 @@ export class FakeCalendar {
     const entry = this.__listEntry;
     return entry ? entry.backgroundColor : '';
   }
-
+  // this can be an enum, or a hex code
   setColor(color) {
     this.__checkWriteAccess();
-    Calendar.CalendarList.patch({ backgroundColor: color }, this.getId());
+    if (Utils.isEnum(color)) {
+      color = color.toString();
+    }
+    Calendar.CalendarList.patch({ backgroundColor: color }, this.getId(), {colorRgbFormat: true});
     return this;
   }
 
@@ -123,11 +128,13 @@ export class FakeCalendar {
    * Permanently deletes a calendar.
    */
   deleteCalendar() {
+    this.__checkUsage('write');
     this.__checkDeleteAccess();
-    Calendar.Calendars.remove(this.getId());
+    Calendar.Calendars.delete(this.getId());
   }
 
   unsubscribeFromCalendar() {
+    this.__checkUsage('write');
     // Unsubscribes the user from a calendar (removes from list).
     Calendar.CalendarList.remove(this.getId());
   }
@@ -138,6 +145,7 @@ export class FakeCalendar {
     if (startTime.getTime() >= endTime.getTime()) {
       throw new Error('Event start date must be before event end date.');
     }
+    this.__checkUsage('write');
     this.__checkWriteAccess();
     const resource = {
       summary: title,
@@ -156,6 +164,7 @@ export class FakeCalendar {
   }
 
   createAllDayEvent(title, startDate, endDateOrOptions, options) {
+    this.__checkUsage('write');
     this.__checkWriteAccess();
     
     let endDate = startDate;
@@ -199,12 +208,14 @@ export class FakeCalendar {
   }
 
   createEventFromDescription(description) {
+    this.__checkUsage('write');
     this.__checkWriteAccess();
     const event = Calendar.Events.quickAdd(this.getId(), description);
     return newFakeCalendarEvent(this.getId(), event);
   }
 
   getEvents(startTime, endTime, options) {
+    this.__checkUsage('read');
     this.__checkReadAccess();
     const args = {
         timeMin: startTime.toISOString(),
@@ -232,6 +243,7 @@ export class FakeCalendar {
   }
 
   getEventById(iCalId) {
+    this.__checkUsage('read');
     this.__checkReadAccess();
     // Apps Script expects iCalUID. Try finding by iCalUID first using list.
     // This avoids "Not Found" errors in the worker when passing iCalUID to events.get (which expects eventId)
@@ -252,18 +264,48 @@ export class FakeCalendar {
   // --- Series ---
   
   createEventSeries(title, startTime, endTime, recurrence, options) {
-      // TODO: Implement recurrence conversion to RRULE
-      // For now, simple insert without proper RRULE if Recurrence object not fully implemented
-      return this.createEvent(title, startTime, endTime, options); // Fallback
+      this.__checkUsage('write');
+      this.__checkWriteAccess();
+      const resource = {
+          summary: title,
+          start: { dateTime: startTime.toISOString() },
+          end: { dateTime: endTime.toISOString() },
+          recurrence: [ recurrence.toString() ] // Assuming recurrence has proper RRULE string representation or handled
+      };
+      this.__applyEventOptions(resource, options);
+      const event = Calendar.Events.insert(resource, this.getId());
+      return newFakeCalendarEventSeries(this.getId(), event);
   }
 
   createAllDayEventSeries(title, startDate, recurrence, options) {
-       // TODO
-       return this.createAllDayEvent(title, startDate, options); // Fallback
+       this.__checkUsage('write');
+       this.__checkWriteAccess();
+       const toDateString = (date) => date.toISOString().split('T')[0];
+       // For all day series, end date is usually next day for the first instance
+       const endDate = new Date(startDate);
+       endDate.setDate(endDate.getDate() + 1);
+
+       const resource = {
+           summary: title,
+           start: { date: toDateString(startDate) },
+           end: { date: toDateString(endDate) },
+           recurrence: [ recurrence.toString() ]
+       };
+       this.__applyEventOptions(resource, options);
+       const event = Calendar.Events.insert(resource, this.getId());
+       return newFakeCalendarEventSeries(this.getId(), event);
   }
 
   getEventSeriesById(iCalId) {
-      // TODO
+      this.__checkUsage('read');
+      this.__checkReadAccess();
+      try {
+          const event = Calendar.Events.get(this.getId(), iCalId);
+          // Check if it's actually a recurring event (has recurrence or is instance)
+          if (event.recurrence || event.recurringEventId) {
+              return newFakeCalendarEventSeries(this.getId(), event);
+          }
+      } catch (e) {}
       return null;
   }
 
@@ -277,6 +319,34 @@ export class FakeCalendar {
     }
   }
 
+  __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);
+        }
+      }
+    }
+  }
+
   __checkAccess(accessType) {
     const behavior = ScriptApp.__behavior;
     if (!behavior.sandboxMode) return true;

package/src/services/calendarapp/fakecalendarapp.js

@@ -1,6 +1,7 @@
 import { Proxies } from '../../support/proxies.js';
 import * as CalendarEnums from '../enums/calendarenums.js';
 import { newFakeCalendar } from './fakecalendar.js';
+import { newFakeEventRecurrence } from './fakeeventrecurrence.js';
 
 /**
  * Creates a new FakeCalendarApp instance.
@@ -20,16 +21,31 @@ export class FakeCalendarApp {
     Object.assign(this, CalendarEnums);
   }
 
+  // --- Service Methods ---
+
+  newRecurrence() {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'newRecurrence');
+    return newFakeEventRecurrence();
+  }
+
   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) {
+    if (resource.id) {
       ScriptApp.__behavior.addCalendarId(resource.id);
     }
     return newFakeCalendar(resource.id, resource);
   }
 
+  subscribeToCalendar(id) {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'subscribeToCalendar');
+    this.__checkUsage('write');
+    const resource = { id };
+    Calendar.CalendarList.insert(resource);
+    return newFakeCalendar(id);
+  }
+
   getCalendarById(id) {
     ScriptApp.__behavior.checkMethod('CalendarApp', 'getCalendarById');
     this.__checkUsage('read');
@@ -53,6 +69,19 @@ export class FakeCalendarApp {
       .map(item => newFakeCalendar(item.id, item));
   }
 
+  getOwnedCalendarsByName(name) {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getOwnedCalendarsByName');
+    this.__checkUsage('read');
+    return this.getCalendarsByName(name).filter(c => c.isOwnedByMe());
+  }
+
+  getOwnedCalendarById(id) {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getOwnedCalendarById');
+    this.__checkUsage('read');
+    const cal = this.getCalendarById(id);
+    return cal && cal.isOwnedByMe() ? cal : null;
+  }
+
   getAllCalendars() {
     ScriptApp.__behavior.checkMethod('CalendarApp', 'getAllCalendars');
     this.__checkUsage('read');
@@ -72,6 +101,109 @@ export class FakeCalendarApp {
       .map(item => newFakeCalendar(item.id, item));
   }
 
+  // --- Default Calendar Delegates ---
+
+  createAllDayEvent(...args) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'createAllDayEvent');
+    return this.getDefaultCalendar().createAllDayEvent(...args); 
+  }
+  createAllDayEventSeries(...args) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'createAllDayEventSeries');
+    return this.getDefaultCalendar().createAllDayEventSeries(...args); 
+  }
+  createEvent(...args) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'createEvent');
+    return this.getDefaultCalendar().createEvent(...args); 
+  }
+  createEventFromDescription(...args) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'createEventFromDescription');
+    return this.getDefaultCalendar().createEventFromDescription(...args); 
+  }
+  createEventSeries(...args) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'createEventSeries');
+    return this.getDefaultCalendar().createEventSeries(...args); 
+  }
+  
+  getEventById(id) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getEventById');
+    return this.getDefaultCalendar().getEventById(id); 
+  }
+  getEvents(...args) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getEvents');
+    return this.getDefaultCalendar().getEvents(...args); 
+  }
+  getEventsForDay(...args) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getEventsForDay');
+    return this.getDefaultCalendar().getEventsForDay(...args); 
+  }
+  getEventSeriesById(id) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getEventSeriesById');
+    return this.getDefaultCalendar().getEventSeriesById(id); 
+  }
+
+  getColor() { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getColor');
+    return this.getDefaultCalendar().getColor(); 
+  }
+  setColor(color) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'setColor');
+    return this.getDefaultCalendar().setColor(color); 
+  }
+  getDescription() { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getDescription');
+    return this.getDefaultCalendar().getDescription(); 
+  }
+  setDescription(description) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'setDescription');
+    return this.getDefaultCalendar().setDescription(description); 
+  }
+  getId() { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getId');
+    return this.getDefaultCalendar().getId(); 
+  }
+  getName() { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getName');
+    return this.getDefaultCalendar().getName(); 
+  }
+  setName(name) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'setName');
+    return this.getDefaultCalendar().setName(name); 
+  }
+  getTimeZone() { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getTimeZone');
+    return this.getDefaultCalendar().getTimeZone(); 
+  }
+  setTimeZone(timeZone) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'setTimeZone');
+    return this.getDefaultCalendar().setTimeZone(timeZone); 
+  }
+  isHidden() { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'isHidden');
+    return this.getDefaultCalendar().isHidden(); 
+  }
+  setHidden(hidden) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'setHidden');
+    return this.getDefaultCalendar().setHidden(hidden); 
+  }
+  isSelected() { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'isSelected');
+    return this.getDefaultCalendar().isSelected(); 
+  }
+  setSelected(selected) { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'setSelected');
+    return this.getDefaultCalendar().setSelected(selected); 
+  }
+  isMyPrimaryCalendar() { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'isMyPrimaryCalendar');
+    return this.getDefaultCalendar().isMyPrimaryCalendar(); 
+  }
+  isOwnedByMe() { 
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'isOwnedByMe');
+    return this.getDefaultCalendar().isOwnedByMe(); 
+  }
+
+  // --- Internals ---
+
   __isCalendarAccessible(calendarId) {
     try {
       this.__checkCalendarAccess(calendarId);