@mcpher/gas-fakes 1.0.20 → 1.0.21

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 && !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(target, prop, receiver);
-        },
-      });
-    }
-    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/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/proxies.js

@@ -1,6 +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
@@ -11,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
@@ -37,6 +52,7 @@ 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))

package/src/support/syncit.js

@@ -274,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)

package/src/services/base/app.js

@@ -1,33 +0,0 @@
-
-/**
- * fake Apps Script Session
- * 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 { Proxies } from '../../support/proxies.js'
-import { newFakeSession } from './fakesession.js'
-
-let _app = null
-
-/**
- * adds to global space to mimic Apps Script behavior
- */
-const name = "Session"
-if (typeof globalThis[name] === typeof undefined) {
-
-  const getApp = () => {
-    // if it hasn't been intialized yet then do that
-    if (!_app) {
-      console.log('...activating proxy for', name)
-      _app = newFakeSession()
-    }
-    // this is the actual driveApp we'll return from the proxy
-    return _app
-  }
-
-  Proxies.registerProxy(name, getApp)
-
-}