@mcpher/gas-fakes 1.0.19 → 1.0.21

package/src/services/gmailapp/app.js

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

package/src/services/gmailapp/fakegmailapp.js

@@ -0,0 +1,35 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeGmailLabel } from './fakegmaillabel.js';
+
+/**
+ * Provides access to Gmail threads, messages, and labels.
+ */
+class FakeGmailApp {
+  constructor() {
+    this.__fakeObjectType = 'GmailApp';
+  }
+
+  /**
+   * Creates a new user label.
+   * @param {string} name The name of the new label.
+   * @returns {GmailLabel} The new label.
+   */
+  createLabel(name) {
+    const newLabelResource = Gmail.newLabel().setName(name);
+    const createdLabelResource = Gmail.Users.Labels.create(newLabelResource, 'me');
+    return newFakeGmailLabel(createdLabelResource);
+  }
+
+  /**
+   * Gets a list of user-created labels.
+   * @returns {GmailLabel[]} An array of user-created labels.
+   */
+  getUserLabels() {
+    const { labels } = Gmail.Users.Labels.list('me');
+    // The documentation for GmailApp.getUserLabels() says "user-created labels".
+    // The live environment follows this, so we will filter for type 'user'.
+    return labels ? labels.filter(l => l.type === 'user').map(labelResource => newFakeGmailLabel(labelResource)) : [];
+  }
+}
+
+export const newFakeGmailApp = (...args) => Proxies.guard(new FakeGmailApp(...args));

package/src/services/gmailapp/fakegmaillabel.js

@@ -0,0 +1,44 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeGmailLabel = (...args) => Proxies.guard(new FakeGmailLabel(...args));
+
+/**
+ * A user-created label in a user's Gmail account.
+ */
+class FakeGmailLabel {
+  constructor(labelResource) {
+    this.__labelResource = labelResource;
+    this.__fakeObjectType = 'GmailLabel';
+  }
+
+  /**
+   * Deletes this label.
+   */
+  deleteLabel() {
+    Gmail.Users.Labels.remove('me', this.getId());
+  }
+
+  /**
+   * Gets the ID of this label.
+   * @returns {string} The label ID.
+   */
+  getId() {
+    return this.__labelResource.id;
+  }
+
+  /**
+   * Gets the name of this label.
+   * @returns {string} The label name.
+   */
+  getName() {
+    return this.__labelResource.name;
+  }
+
+  /**
+   * Returns the name of the label.
+   * @returns {string} The name of the label.
+   */
+  toString() {
+    return 'GmailLabel';
+  }
+}

package/src/services/logger/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 { newFakeLogger as maker } from './fakelogger.js';
+let _app = null;
+_app = lazyLoaderApp(_app, 'Logger', maker)

package/src/services/logger/fakelogger.js

@@ -0,0 +1,162 @@
+import { format } from 'util';
+import { Proxies } from '../../support/proxies.js';
+import { Logging } from '@google-cloud/logging';
+
+// --- Cloud Logging Integration ---
+
+// Cloud Logging client instance.
+export let cloudLog;
+
+/**
+ * @class
+ * @implements {GoogleAppsScript.Base.Logger}
+ */
+export class FakeLogger {
+  constructor() {
+    /**
+     * @private
+     * @type {string[]}
+     */
+    this.__log = [];
+    /**
+     * @private
+     * @type {string}
+     */
+    this.__destination = (process.env.LOG_DESTINATION || 'CONSOLE').toUpperCase();
+  }
+
+  /**
+   * Clears the log.
+   */
+  clear() {
+    this.__log = [];
+  }
+
+  /**
+   * Returns the log contents.
+   * @returns {string}
+   */
+  getLog() {
+    return this.__log.join('\n');
+  }
+
+  /**
+   * Logs a message.
+   * @param {string} formatOrData
+   * @param {...any} values
+   * @returns {FakeLogger}
+   */
+  log(formatOrData, ...values) {
+    // Check the instance's destination property.
+    if (this.__destination === 'NONE') {
+      // Still push to the internal log for getLog(), but don't output.
+      const message = format(formatOrData, ...values);
+      this.__log.push(message);
+      return this;
+    }
+
+    const message = format(formatOrData, ...values);
+    this.__log.push(message);
+
+    // Pass the destination and instance context to the writer function.
+    writeToCloudOrConsole(message, this);
+
+    return this;
+  }
+
+  /**
+   * Returns 'Logger'.
+   * @returns {string}
+   */
+  toString() {
+    return 'Logger';
+  }
+
+  /**
+   * Sets the logging destination dynamically.
+   * @param {string} destination - The destination ('CONSOLE', 'CLOUD', 'BOTH', 'NONE').
+   * @returns {FakeLogger}
+   */
+  __setLogDestination(destination) {
+    if (['CONSOLE', 'CLOUD', 'BOTH', 'NONE'].includes(destination.toUpperCase())) {
+      this.__destination = destination.toUpperCase();
+    }
+    return this;
+  }
+}
+
+/**
+ * @returns {FakeLogger}
+ */
+export const newFakeLogger = (...args) => Proxies.guard(new FakeLogger(...args));
+
+/**
+ * Writes a log message to the configured destination (Cloud Logging or console).
+ * @param {string} message The log message.
+ * @private
+ * @param {FakeLogger} loggerInstance The logger instance, to access its destination.
+ */
+const writeToCloudOrConsole =  (message, loggerInstance) => {
+  const logDestination = loggerInstance.__destination;
+  const useConsoleLogging = logDestination === 'CONSOLE' || logDestination === 'BOTH';
+  const useCloudLogging = logDestination === 'CLOUD' || logDestination === 'BOTH';
+
+  // Lazy-initialize the cloud logger if needed.
+  const initializeCloudLogging = () => {
+    if (cloudLog) return; // Already initialized.
+    try {
+      const projectId = ScriptApp.__projectId;
+      if (!projectId) {
+        throw new Error('Could not determine Google Cloud Project ID for logging.');
+      }
+      const logging = new Logging({ projectId });
+      const logName = 'gas-fakes/console_logs';
+      cloudLog = logging.log(logName);
+      console.info(`gas-fakes: Cloud Logging is enabled, writing to log "${logName}".`);
+    } catch (err) {
+      console.warn(
+        `gas-fakes: Cloud Logging failed to initialize. ` +
+        'Falling back to console.log.',
+        err.message
+      );
+      cloudLog = null;
+    }
+  };
+
+  // Write to console if CONSOLE or BOTH is specified.
+  if (useConsoleLogging) {
+    // Write structured JSON to stdout for agent-based collection or local viewing.
+    const logEntry = {
+      message: message,
+      severity: 'INFO',
+    };
+    console.log(JSON.stringify(logEntry));
+  }
+
+  // Write to Cloud Logging if CLOUD or BOTH is specified and client is ready.
+  if (useCloudLogging) {
+    // Initialize the cloud logger on the first use if it hasn't been already.
+    if (!cloudLog) {
+      initializeCloudLogging();
+    }
+
+    const metadata = {
+      // Use the 'global' resource type, which is a generic fallback for applications
+      // not running on a specific GCP compute service.
+      resource: { type: 'global' },
+      labels: {
+        'gas-fakes-scriptId': ScriptApp.getScriptId(),
+        'gas-fakes-userId': ScriptApp.__userId,
+      },
+      jsonPayload: { message: message },
+      severity: 'INFO',
+    };
+
+    // Use log.write which returns a promise. T
+    // his allows us to catch errors, such as a disabled API or permission issues.
+    // however we are firing and forgetting so an error might appear later on in execution
+    if (cloudLog) {
+      cloudLog.write(cloudLog.entry(metadata)).catch(err=> console.error('gas-fakes: Failed to write to Cloud Logging.', err.message))
+    }
+  }
+};

package/src/services/scriptapp/app.js

@@ -110,12 +110,18 @@ if (typeof globalThis[name] === typeof undefined) {
 
     // if it hasn't been intialized yet then do that
     if (!_app) {
-      console.log('...activating proxy for', name)
+
       _app = {
         getOAuthToken,
         requireAllScopes,
         requireScopes,
         getScriptId: Auth.getScriptId,
+        get __projectId () {
+          return Auth.getProjectId()
+        },
+        get __userId () {
+          return Auth.getUserId()
+        },
         AuthMode: {
           FULL: 'FULL'
         },

package/src/services/scriptapp/behavior.js

@@ -167,7 +167,7 @@ class FakeBehavior {
     this.__idWhitelist = null
 
     // individually settable services
-    const services = ['DocumentApp', 'DriveApp', 'SpreadsheetApp', 'SlidesApp', 'Docs', 'Sheets', 'Drive', 'Slides', 'FormApp', 'Forms']
+    const services = ScriptApp.__registeredServices
     this.__sandboxService = {}
     services.forEach(f => this.__sandboxService[f] = newFakeSandboxService(this, f))
 

package/src/services/session/app.js

@@ -0,0 +1,10 @@
+
+/**
+ * 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 { newFakeSession as maker} from './fakesession.js'
+let _app = null;
+_app = lazyLoaderApp(_app, 'Session', maker)

package/src/services/slidesapp/app.js

@@ -1,44 +1,9 @@
 /**
- * the idea here is to create a global entry for the singleton
- * before we actually have everything we need to create it.
- * We do this by using a proxy, intercepting calls to the
- * initial sigleton and diverting them to a completed one
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
  */
-import { newFakeSlidesApp } from './fakeslidesapp.js';
-import { Proxies } from '../../support/proxies.js';
 
+import { lazyLoaderApp } from '../common/lazyloader.js'
+import { newFakeSlidesApp as maker} from './fakeslidesapp.js';
 let _app = null;
-
-const name = 'SlidesApp';
-const serviceName = 'SlidesApp';
-
-if (typeof globalThis[name] === typeof undefined) {
-  const getApp = () => {
-    if (!_app) {
-      const realApp = newFakeSlidesApp();
-
-      _app = new Proxy(realApp, {
-        get(target, prop, receiver) {
-          if (prop === 'toString') {
-            return () => name;
-          }
-
-          const serviceBehavior = ScriptApp.__behavior.sandboxService[serviceName];
-
-          if (!serviceBehavior.enabled) {
-            throw new Error(`${name} service is disabled by sandbox settings.`);
-          }
-
-          const allowedMethods = serviceBehavior.methods;
-          if (allowedMethods && typeof target[prop] === 'function' && !allowedMethods.includes(prop)) {
-            throw new Error(`Method ${name}.${prop} is not allowed by sandbox settings.`);
-          }
-
-          return Reflect.get(...arguments);
-        },
-      });
-    }
-    return _app;
-  };
-  Proxies.registerProxy(name, getApp);
-}
+_app = lazyLoaderApp(_app, 'SlidesApp', maker)

package/src/services/spreadsheetapp/app.js

@@ -1,53 +1,9 @@
-// fake Apps Script SpreadsheetApp
-/**
- * the idea here is to create a global entry for the singleton 
- * before we actually have everything we need to create it. 
- * We do this by using a proxy, intercepting calls to the 
- * initial sigleton and diverting them to a completed one
- */
-import { newFakeSpreadsheetApp } from './fakespreadsheetapp.js'
-import { Proxies } from '../../support/proxies.js'
-
-// This will eventually hold a proxy for DriveApp
-let _app = null;
 
 /**
- * adds to global space to mimic Apps Script behavior
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
  */
-const name = "SpreadsheetApp";
-const serviceName = "SpreadsheetApp";
-
-if (typeof globalThis[name] === typeof undefined) {
-  const getApp = () => {
-    // if it hasnt been intialized yet then do that
-    if (!_app) {
-      const realApp = newFakeSpreadsheetApp();
-
-      _app = new Proxy(realApp, {
-        get(target, prop, receiver) {
-          // toString on the proxy target itself
-          if (prop === 'toString') {
-            return () => name;
-          }
-
-          const serviceBehavior = ScriptApp.__behavior.sandboxService[serviceName];
-
-          if (!serviceBehavior.enabled) {
-            throw new Error(`${name} service is disabled by sandbox settings.`);
-          }
-
-          const allowedMethods = serviceBehavior.methods;
-          if (allowedMethods && typeof target[prop] === 'function' && !allowedMethods.includes(prop)) {
-            throw new Error(`Method ${name}.${prop} is not allowed by sandbox settings.`);
-          }
-
-          return Reflect.get(...arguments);
-        }
-      });
-    }
-    // this is the actual driveApp we'll return from the proxy
-    return _app
-  }
-
-  Proxies.registerProxy(name, getApp)
-}
+import { lazyLoaderApp } from '../common/lazyloader.js'
+import { newFakeSpreadsheetApp as maker} from './fakespreadsheetapp.js'
+let _app = null;
+_app = lazyLoaderApp(_app, 'SpreadsheetApp', maker)

package/src/services/spreadsheetapp/fakeprotection.js

@@ -101,13 +101,12 @@ export class FakeProtection {
   }
 
   getEditors() {
-    if (this.object.editors?.users && this.object.editors?.users.length > 0) {
-      const owner = DriveApp.getFileById(this.spreadsheetId)
-        .getOwner()
-        .getEmail();
-      return this.object.editors.users
-        .filter((email) => email != owner)
-        .map((email) => newFakeUser({ email }));
+    if (
+      this.object.editors?.users &&
+      this.object.editors?.users.length > 0 &&
+      !this.object.warningOnly
+    ) {
+      return this.object.editors.users.map((email) => newFakeUser({ email }));
     }
     return [];
   }

package/src/services/spreadsheetapp/fakesheet.js

@@ -11,11 +11,9 @@ import { newFakeDeveloperMetadataFinder } from "./fakedevelopermetadatafinder.js
 import { newFakeSheetRangeList } from "./fakesheetrangelist.js";
 import { FakeTextFinder, newFakeTextFinder } from "./faketextfinder.js";
 
-import {  newFakeNamedRange } from "./fakenamedrange.js";
+import { newFakeNamedRange } from "./fakenamedrange.js";
 import { newFakeProtection } from "./fakeprotection.js";
 
-
-
 const { is, isEnum } = Utils;
 
 export const newFakeSheet = (properties, parent) => {
@@ -1009,7 +1007,8 @@ export class FakeSheet {
       ],
     };
     this.__batchUpdate(obj);
-    return this.getParent().getSheetByName(name);
+    this.__properties.title = name;
+    return this;
   }
 
   protect() {

package/src/services/stores/app.js

@@ -26,7 +26,6 @@ const registerApp = (_app, name, kind) => {
     const getApp = () => {
       // if it hasnt been intialized yet then do that
       if (!_app) {
-        console.log('...activating proxy for', name)
         _app = newFakeService(kind)
       }
       // this is the actual driveApp we'll return from the proxy

package/src/services/urlfetchapp/app.js

@@ -103,7 +103,6 @@ if (typeof globalThis[name] === typeof undefined) {
   const getApp = () => {
     // if it hasne been intialized yet then do that
     if (!_app) {
-      console.log('...activating proxy for', name)
       _app = {
         fetch
       }

package/src/services/utilities/app.js

@@ -1,23 +1,9 @@
-import { Proxies } from '../../support/proxies.js'
-import { newFakeUtilities } from './fakeutilities.js';
-
-
-// This will eventually hold a proxy for Utilities
-let _app = null
 
 /**
- * adds to global space to mimic Apps Script behavior
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
  */
-const name = "Utilities"
-if (typeof globalThis[name] === typeof undefined) {
-  const getApp = () => {
-    // if it hasnt been intialized yet then do that
-    if (!_app) {
-      console.log('...activating proxy for', name)
-      _app = newFakeUtilities()
-    }
-    // this is the actual driveApp we'll return from the proxy
-    return _app
-  }
-  Proxies.registerProxy(name, getApp)
-}
+import { lazyLoaderApp } from '../common/lazyloader.js'
+import { newFakeUtilities as maker } from './fakeutilities.js';
+let _app = null;
+_app = lazyLoaderApp(_app, 'Utilities', maker)

package/src/support/gmailcacher.js

@@ -0,0 +1,7 @@
+/**
+ * avoid going to api if we already have it
+ * anything other than a get should jusr delete the whiole map for the form
+ */
+const USE_CACHE = true
+import { newFetchCacher } from "./fetchcacher.js"
+export const gmailCacher = newFetchCacher(USE_CACHE)

package/src/support/helpers.js

@@ -208,9 +208,9 @@ export const unimplementedProps = (self, props) => {
   })
 }
 
-export const gError = (response, service, method) => {
+export const gError = (response, service, method, throw404 = false) => {
   if (response && response.error) {
-    if (response.error.code !== 404) {
+    if (throw404 || response.error.code !== 404) {
       throw new Error(`GoogleJsonResponseException: API call to ${service}.${method} failed with error: ${response?.error?.message}`);
     }
   }

package/src/support/proxies.js

@@ -1,5 +1,7 @@
 import { Utils } from './utils.js';
 
+const serviceRegistry = new Set();
+const loadedRegistry = new Set();
 
 /**
  * diverts the property get to another object returned by the getApp function
@@ -10,10 +12,24 @@ const getAppHandler = (getApp, name) => {
   return {
 
     get(_, prop, receiver) {
+
       // this will let the caller know we're not really running in Apps Script
+      // every service can return this
       if (prop === 'isFake') return true;
 
+      // this returns all services already registered - may be useful
+      if (prop === '__registeredServices') return Array.from(serviceRegistry)
+
+     // this returns all services already loaded - may be useful
+      if (prop === '__loadedServices') return Array.from(loadedRegistry)
+
+      // this will get the app and lazy load it if its not already loaded
       const app = getApp();
+
+      // now we have a loaded service
+      loadedRegistry.add(name)
+
+      // are we being asked to run a method?
       const member = Reflect.get(app, prop, receiver);
 
       // Check method whitelist if it's a function call on a service
@@ -36,7 +52,9 @@ const getAppHandler = (getApp, name) => {
   }
 }
 
+// keep a note of which services have been registered
 const registerProxy = (name, getApp) => {
+  serviceRegistry.add(name);
   const value = new Proxy({}, getAppHandler(getApp, name))
   // add it to the global space to mimic what apps script does
   // console.log (`setting ${name} to global`)
@@ -97,5 +115,6 @@ export const Proxies = {
   getAppHandler,
   registerProxy,
   guard,
-  blanketProxy
+  blanketProxy,
+  getRegisteredServices: () => Array.from(serviceRegistry),
 }

package/src/support/sxgmail.js

@@ -0,0 +1,55 @@
+/**
+ * GMAIL
+ * all these functions run in the worker
+ * thus turning async operations into sync
+ * note
+ * - arguments and returns must be serializable ie. primitives or plain objects
+ */
+
+import { responseSyncify } from './auth.js';
+import { syncWarn, syncError } from './workersync/synclogger.js';
+import { getGmailApiClient } from '../services/advgmail/gmailapis.js';
+
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+export const sxGmail = async (Auth, { subProp, prop, method, params, options }) => {
+
+  const apiClient = getGmailApiClient();
+  const maxRetries = 7;
+  let delay = 1777;
+  const methodName = subProp ? `${prop}.${subProp}.${method}` : `${prop}.${method}`;
+
+  for (let i = 0; i < maxRetries; i++) {
+    let response;
+    let error;
+    try {
+      const callish = subProp ? apiClient[prop][subProp] : apiClient[prop];
+      response = await callish[method](params, options);
+    } catch (err) {
+      error = err;
+      response = err.response;
+    }
+
+    const isRetryable = [429, 500, 503].includes(response?.status) || error?.code == 429;
+    
+    if (isRetryable && i < maxRetries - 1) {
+      const jitter = Math.floor(Math.random() * 1000);
+      syncWarn(`Retryable error on Gmail API call ${methodName} (status: ${response?.status}). Retrying in ${delay + jitter}ms...`);
+      await sleep(delay + jitter);
+      delay *= 2;
+      continue;
+    }
+
+    if (error || isRetryable) {
+      // Don't log 404 as an error, it's an expected outcome for some tests (e.g., get deleted item)
+      if (response?.status !== 404) {
+        syncError(`Failed in sxGmail for ${methodName}`, error);
+      }
+      return { data: null, response: responseSyncify(response) };
+    }
+    return {
+      data: response.data,
+      response: responseSyncify(response)
+    };
+  }
+};

package/src/support/syncit.js

@@ -9,6 +9,7 @@ import { mergeParamStrings } from './utils.js'
 import { improveFileCache, checkResponse, getFromFileCache } from "./filecache.js"
 import { checkResponseCacher } from './fetchcacher.js';
 import { docsCacher } from "./docscacher.js"
+import { gmailCacher } from './gmailcacher.js';
 import { formsCacher } from './formscacher.js';
 import { slidesCacher } from './slidescacher.js';
 import { sheetsCacher } from './sheetscacher.js';
@@ -273,9 +274,9 @@ const fxInit = ({
   } = synced
 
   // set these values from the subprocess for the main project
-  //Auth.setProjectId(projectId)
+  Auth.setProjectId(projectId)
   //Auth.setAuth(scopes)
-  //Auth.setTokenInfo(tokenInfo)
+  Auth.setTokenInfo(tokenInfo)
   //Auth.setAdcPath(adcPath)
   //Auth.setAccessToken(accessToken)
   Auth.setSettings(settings)
@@ -345,6 +346,7 @@ const fxSheets = (args) => fxGeneric({ ...args, serviceName: 'Sheets', cacher: s
 const fxSlides = (args) => fxGeneric({ ...args, serviceName: 'Slides', cacher: slidesCacher, idField: 'presentationId' });
 const fxDocs = (args) => fxGeneric({ ...args, serviceName: 'Docs', cacher: docsCacher, idField: 'documentId' });
 const fxForms = (args) => fxGeneric({ ...args, serviceName: 'Forms', cacher: formsCacher, idField: 'formId' });
+const fxGmail = (args) => fxGeneric({ ...args, serviceName: 'Gmail', cacher: gmailCacher, idField: 'id' });
 
 export const Syncit = {
   fxFetch,
@@ -361,4 +363,5 @@ export const Syncit = {
   fxRefreshToken,
   fxDocs,
   fxForms,
+  fxGmail,
 }