@mcpher/gas-fakes 2.3.18 → 2.5.2

package/src/services/html/consumerworker.js

@@ -0,0 +1,129 @@
+import fs from 'fs';
+import path from 'path';
+import { workerData } from 'worker_threads';
+
+const { mainScriptPath, funcName, args, isTemplate, templateString, env } = workerData;
+const control = new Int32Array(workerData.controlBuf);
+const dataView = new Uint8Array(workerData.dataBuf);
+const textEncoder = new TextEncoder();
+
+// Initialize the Apps Script environment
+if (env) {
+    Object.assign(process.env, env);
+}
+globalThis.__gasFakesMainScriptPath = mainScriptPath;
+await import('../../../main.js');
+
+// Bootstrap Auth completely via standard initialization
+import { Syncit } from '../../support/syncit.js';
+
+// Trigger a fresh authentication flow to ensure Auth.getUserId() and others are populated.
+// We specify the platforms from environment or default to google.
+const platforms = process.env.GF_PLATFORM_AUTH ? process.env.GF_PLATFORM_AUTH.split(',') : ['google'];
+Syncit.fxInit({ platformAuth: platforms });
+
+const CONTROL_INDICES = {
+  STATUS: 0,
+  DATA_SIZE: 1,
+  IS_ERROR: 2
+};
+
+async function run() {
+  try {
+
+
+    // Dynamically load the user's module
+    const userModule = await import(mainScriptPath);
+    
+    // Expose all exports to globalThis for legacy patterns
+    Object.keys(userModule).forEach(key => {
+        globalThis[key] = userModule[key];
+    });
+
+    let result;
+
+    if (isTemplate) {
+      // Evaluate template
+      // We pass the userModule context to allow access to functions like Include
+      result = templateString.replace(/<\?!=?\s*([\s\S]+?)\s*\?>/g, (match, expression) => {
+        try {
+           // We use the userModule exports as the scope for template expressions
+           const func = new Function(...Object.keys(userModule), `return ${expression}`);
+           const exprResult = func(...Object.values(userModule));
+           
+           if (exprResult && typeof exprResult.getContent === 'function') {
+               return exprResult.getContent();
+           }
+           return typeof exprResult !== 'undefined' ? exprResult : '';
+        } catch (e) {
+           console.error(`gas-fakes template evaluation error for scriptlet '${expression}':`, e.message);
+           return match;
+        }
+      });
+    } else {
+      // Run function
+      const func = userModule[funcName] || globalThis[funcName];
+      if (typeof func !== 'function') {
+        throw new Error(`google.script.run: function "${funcName}" is not defined.`);
+      }
+
+      // Re-hydrate doPost event object
+      if (funcName === 'doPost' && args && args[0] && args[0].postData) {
+         args[0].postData.getDataAsString = function() { return this.contents; };
+      }
+
+      const rawResult = await func(...(args || []));
+      
+      // Serialize output if it's a FakeHtmlOutput or FakeTextOutput
+      if (rawResult && typeof rawResult.getContent === 'function') {
+        result = {
+          __isHtmlOutput: !!rawResult.__isHtmlOutput,
+          __isTextOutput: !!rawResult.__isTextOutput,
+          __framingType: rawResult.__framingType || null,
+          content: rawResult.getContent(),
+          title: typeof rawResult.getTitle === 'function' ? rawResult.getTitle() : '',
+          width: typeof rawResult.getWidth === 'function' ? rawResult.getWidth() : null,
+          height: typeof rawResult.getHeight === 'function' ? rawResult.getHeight() : null,
+          mimeType: typeof rawResult.getMimeType === 'function' ? rawResult.getMimeType() : null
+        };
+      } else {
+        result = typeof rawResult === 'undefined' ? undefined : JSON.parse(JSON.stringify(rawResult));
+      }
+    }
+
+    writeResult(result);
+  } catch (error) {
+    console.error('[gas-fakes worker error]', error);
+    writeError(error);
+  } finally {
+    Atomics.store(control, CONTROL_INDICES.STATUS, 0);
+    Atomics.notify(control, 0);
+  }
+}
+
+function writeResult(result) {
+  const resultString = JSON.stringify(result === undefined ? null : result);
+  const encodedResult = textEncoder.encode(resultString);
+
+  if (encodedResult.length > dataView.buffer.byteLength) {
+    throw new Error('Result exceeds shared buffer size');
+  }
+
+  dataView.set(encodedResult);
+  Atomics.store(control, CONTROL_INDICES.DATA_SIZE, encodedResult.length);
+  Atomics.store(control, CONTROL_INDICES.IS_ERROR, 0);
+}
+
+function writeError(error) {
+  const message = error?.message || (typeof error === 'string' ? error : JSON.stringify(error) || 'Unknown error');
+  const stack = error?.stack || new Error().stack;
+  console.error('[gas-fakes worker error details]:', message, stack);
+  const errorString = JSON.stringify({ message, stack });
+  const encodedError = textEncoder.encode(errorString);
+  
+  dataView.set(encodedError);
+  Atomics.store(control, CONTROL_INDICES.DATA_SIZE, encodedError.length);
+  Atomics.store(control, CONTROL_INDICES.IS_ERROR, 1);
+}
+
+run();

package/src/services/html/googlescriptrun.js

@@ -0,0 +1,91 @@
+
+import { ServerWorkerContext } from './serverworker.js';
+
+/**
+ * Emulates the client-side google.script.run API.
+ * In gas-fakes, this runs in the same Node process.
+ */
+export class FakeGoogleScriptRun {
+  constructor(handlers = {}) {
+    this._successHandler = handlers.successHandler;
+    this._failureHandler = handlers.failureHandler;
+    this._userObject = handlers.userObject;
+    this._serverFunctions = handlers.serverFunctions || null;
+
+    return new Proxy(this, {
+      get: (target, prop) => {
+        // Return existing properties (like withSuccessHandler)
+        if (prop in target) {
+          return target[prop];
+        }
+
+        // Methods for chaining handlers
+        if (prop === 'withSuccessHandler') {
+          return (handler) => new FakeGoogleScriptRun({ ...target._getHandlers(), successHandler: handler });
+        }
+        if (prop === 'withFailureHandler') {
+          return (handler) => new FakeGoogleScriptRun({ ...target._getHandlers(), failureHandler: handler });
+        }
+        if (prop === 'withUserObject') {
+          return (obj) => new FakeGoogleScriptRun({ ...target._getHandlers(), userObject: obj });
+        }
+
+        // Special method to register functions manually if they aren't global
+        // This is extremely useful for modular tests or explicit wiring
+        if (prop === '__registerServerFunctions') {
+           return (funcs) => {
+             this._serverFunctions = { ...this._serverFunctions, ...funcs };
+             return this;
+           }
+        }
+
+        // Otherwise, it's a server-side function call
+        return (...args) => {
+          // Asynchronous execution simulation
+          setTimeout(() => {
+            try {
+              if (prop.endsWith('_') || prop.startsWith('__')) {
+                throw new Error(`google.script.run: function "${prop}" is private and cannot be called from the client.`);
+              }
+              
+              // In Apps Script, parameters are passed by value (JSON serialized)
+              const serializedArgs = JSON.parse(JSON.stringify(args));
+              
+              let result;
+
+              // Fallback for modular tests that explicitly registered functions
+              if (this._serverFunctions && typeof this._serverFunctions[prop] === 'function') {
+                result = this._serverFunctions[prop](...serializedArgs);
+              } else {
+                // Main stateless execution path via Synchronous Worker Threads
+                const ctx = new ServerWorkerContext();
+                result = ctx.runFunction(prop, serializedArgs);
+              }
+              
+              // Result is also serialized back
+              const serializedResult = typeof result === 'undefined' ? undefined : JSON.parse(JSON.stringify(result));
+
+              if (this._successHandler) {
+                this._successHandler(serializedResult, this._userObject);
+              }
+            } catch (err) {
+              if (this._failureHandler) {
+                this._failureHandler(err, this._userObject);
+              }
+            }
+          }, 0);
+        };
+      }
+    });
+  }
+
+  _getHandlers() {
+    return {
+      successHandler: this._successHandler,
+      failureHandler: this._failureHandler,
+      userObject: this._userObject,
+      serverFunctions: this._serverFunctions
+    };
+  }
+}
+

package/src/services/html/htmloutput.js

@@ -0,0 +1,127 @@
+import { FakeHtmlTemplate } from './htmltemplate.js';
+import { FakeHtmlOutputMetaTag } from './htmloutputmetatag.js';
+
+export class FakeHtmlOutput {
+  constructor(content = '') {
+    this._content = content;
+    this._title = '';
+    this._width = 600;
+    this._height = 450;
+    this._metaData = {};
+    this._faviconUrl = '';
+    this._xFrameOptionsMode = null;
+    this._sandboxMode = null;
+    this.__isHtmlOutput = true;
+  }
+
+  getContent() {
+    return this._content
+      .replace(/<script([^>]*)>([\s\S]*?)<\/script>/gi, (match, attrs, body) => {
+        if (attrs.includes('src=')) return match;
+        if (body.includes('//# sourceURL=')) return match;
+        const sourceUrl = `\n//# sourceURL=__gas_fakes_dynamic_script_${Date.now()}.js`;
+        return `<script${attrs}>${body}${sourceUrl}</script>`;
+      })
+      .replace(/<style([^>]*)>([\s\S]*?)<\/style>/gi, (match, attrs, body) => {
+        if (body.includes('/*# sourceURL=')) return match;
+        const sourceUrl = `\n/*# sourceURL=__gas_fakes_dynamic_style_${Date.now()}.css */`;
+        return `<style${attrs}>${body}${sourceUrl}</style>`;
+      });
+  }
+
+  setContent(content) {
+    this._content = content;
+    return this;
+  }
+
+  append(content) {
+    this._content += content;
+    return this;
+  }
+
+  appendUntrusted(content) {
+    this._content += String(content)
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#39;');
+    return this;
+  }
+
+  clear() {
+    this._content = '';
+    return this;
+  }
+
+  setTitle(title) {
+    this._title = title;
+    return this;
+  }
+
+  getTitle() {
+    return this._title;
+  }
+
+  setWidth(width) {
+    this._width = width;
+    return this;
+  }
+
+  getWidth() {
+    return this._width;
+  }
+
+  setHeight(height) {
+    this._height = height;
+    return this;
+  }
+
+  getHeight() {
+    return this._height;
+  }
+
+  setFaviconUrl(iconUrl) {
+    this._faviconUrl = iconUrl;
+    return this;
+  }
+
+  getFaviconUrl() {
+    return this._faviconUrl;
+  }
+
+  addMetaTag(name, content) {
+    this._metaData[name] = content;
+    return this;
+  }
+
+  getMetaTags() {
+    return Object.keys(this._metaData).map(name => new FakeHtmlOutputMetaTag(name, this._metaData[name]));
+  }
+
+  setXFrameOptionsMode(mode) {
+    this._xFrameOptionsMode = mode;
+    return this;
+  }
+
+  setSandboxMode(mode) {
+    this._sandboxMode = mode;
+    return this;
+  }
+
+  asTemplate() {
+    return new FakeHtmlTemplate(this._content);
+  }
+
+  getBlob() {
+    return globalThis.Utilities.newBlob(this._content, 'text/html', (this._title || 'output') + '.html');
+  }
+
+  getAs(contentType) {
+    // In live GAS, getAs performs server-side conversion (e.g. to PDF).
+    // Locally, we just return a blob with the new mimeType for parity checking.
+    const b = this.getBlob();
+    b.setContentType(contentType);
+    return b;
+  }
+}

package/src/services/html/htmloutputmetatag.js

@@ -0,0 +1,14 @@
+export class FakeHtmlOutputMetaTag {
+  constructor(name, content) {
+    this._name = name;
+    this._content = content;
+  }
+
+  getContent() {
+    return this._content;
+  }
+
+  getName() {
+    return this._name;
+  }
+}

package/src/services/html/htmlservice.js

@@ -0,0 +1,94 @@
+
+import { FakeHtmlOutput } from './htmloutput.js';
+import { FakeHtmlTemplate } from './htmltemplate.js';
+import { FakeGoogleScriptRun } from './googlescriptrun.js';
+import { HtmlEnums } from '../enums/htmlenums.js';
+import fs from 'fs';
+import path from 'path';
+
+import { startServer } from './webapp.js';
+
+// Initialize google.script globals
+if (typeof globalThis.google === 'undefined') {
+  globalThis.google = {
+    script: {
+      run: new FakeGoogleScriptRun(),
+      host: {
+        close: () => {},
+        setHeight: () => {},
+        setWidth: () => {},
+        origin: ''
+      },
+      history: {
+        push: () => {},
+        replace: () => {},
+        setChangeHandler: () => {}
+      }
+    }
+  };
+}
+
+export class FakeHtmlService {
+  constructor() {
+    this.SandboxMode = HtmlEnums.SandboxMode;
+    this.XFrameOptionsMode = HtmlEnums.XFrameOptionsMode;
+  }
+
+  _readLocalFile(filename) {
+    // In live Apps Script, `HtmlService.createHtmlOutputFromFile('Index')`
+    // implicitly looks for an `Index.html` file in the project.
+    let targetFile = filename;
+    if (!targetFile.endsWith('.html')) {
+        targetFile += '.html';
+    }
+
+    // Resolve relative to the consumer's main script
+    let mainScriptPath = process.argv[1];
+    
+    // In gas-fakes serve mode, we use worker threads. The worker passes the main script path via workerData.
+    if (globalThis.__gasFakesMainScriptPath) {
+        mainScriptPath = globalThis.__gasFakesMainScriptPath;
+    }
+
+    if (!mainScriptPath || mainScriptPath.endsWith('node')) {
+        throw new Error("Could not determine project root. Ensure process.argv[1] is set or __gasFakesMainScriptPath is defined.");
+    }
+    
+    const projectDir = path.dirname(mainScriptPath);
+    const fullPath = path.resolve(projectDir, targetFile);
+
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`No HTML file named ${filename} was found.`);
+    }
+
+    return fs.readFileSync(fullPath, 'utf8');
+  }
+
+  createHtmlOutput(html = '') {
+    return new FakeHtmlOutput(html);
+  }
+
+  createHtmlOutputFromFile(filename) {
+    const content = this._readLocalFile(filename);
+    return new FakeHtmlOutput(content);
+  }
+
+  createTemplate(html = '') {
+    return new FakeHtmlTemplate(html);
+  }
+
+  createTemplateFromFile(filename) {
+    const content = this._readLocalFile(filename);
+    return new FakeHtmlTemplate(content);
+  }
+
+  getUserAgent() {
+    return 'Node.js gas-fakes emulator';
+  }
+
+  __startWebApp(port = 3000) {
+    return startServer(port);
+  }
+}
+
+export const newFakeHtmlService = () => new FakeHtmlService();

package/src/services/html/htmltemplate.js

@@ -0,0 +1,63 @@
+
+import { FakeHtmlOutput } from './htmloutput.js';
+import { ServerWorkerContext } from './serverworker.js';
+
+export class FakeHtmlTemplate {
+  constructor(content = '') {
+    this._content = content;
+    
+    return new Proxy(this, {
+      get: (target, prop, receiver) => {
+        if (prop in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+        return target[prop];
+      },
+      set: (target, prop, value, receiver) => {
+        return Reflect.set(target, prop, value, receiver);
+      }
+    });
+  }
+
+  evaluate() {
+    let evaluatedContent = this._content;
+
+    let workerResult = null;
+    try {
+      const ctx = new ServerWorkerContext();
+      workerResult = ctx.evaluateTemplate(this._content);
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+
+    if (workerResult) {
+       evaluatedContent = workerResult;
+    }
+
+    // Final pass for explicitly set template properties
+    evaluatedContent = evaluatedContent.replace(/<\?=\s*([^?]+)\s*\?>/g, (match, varName) => {
+      const trimmedVarName = varName.trim();
+      if (typeof this[trimmedVarName] !== 'undefined') {
+        return this[trimmedVarName];
+      }
+      return match; 
+    });
+
+    return new FakeHtmlOutput(evaluatedContent);
+  }
+
+  getRawContent() {
+    return this._content;
+  }
+
+  getCode() {
+    return `// Compiled template\n(function() { let output = ""; ${this._content.split('\n').map(line => `output += ${JSON.stringify(line)} + "\\n";`).join('\n')} return output; })()`;
+  }
+
+  getCodeWithComments() {
+    return `// Compiled template with comments\n(function() { let output = ""; ${this._content.split('\n').map(line => `// ${line}\noutput += ${JSON.stringify(line)} + "\\n";`).join('\n')} return output; })()`;
+  }
+}
+
+

package/src/services/html/serverworker.js

@@ -0,0 +1,135 @@
+import { Auth } from '../../support/auth.js';
+import { Worker } from 'worker_threads';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const workerPath = path.join(__dirname, 'consumerworker.js');
+
+const CONTROL_INDICES = {
+  STATUS: 0,
+  DATA_SIZE: 1,
+  IS_ERROR: 2
+};
+
+export class ServerWorkerContext {
+  constructor(scriptPath = null) {
+    this._mainScriptPath = scriptPath || globalThis.__gasFakesMainScriptPath || process.argv[1];
+    
+    // Fallback for test runners or dynamic imports where process.argv[1] is node itself or undefined
+    if (!this._mainScriptPath || this._mainScriptPath.endsWith('node') || this._mainScriptPath.endsWith('gas-fakes.js') || this._mainScriptPath.endsWith('gas-fakes')) {
+       const stack = new Error().stack;
+       const match = stack.match(/at file:\/\/(.*\.js)/);
+       if (match && match[1]) {
+           // We want to find the entry point, not this file itself
+           const lines = stack.split('\n');
+           for (let i = lines.length - 1; i >= 0; i--) {
+               const m = lines[i].match(/at (?:async )?file:\/\/(.*\.js)/);
+               if (m && m[1] && !m[1].includes('serverworker.js')) {
+                   this._mainScriptPath = m[1];
+                   break;
+               }
+           }
+       }
+    }
+
+    
+    // Create shared buffers for synchronous communication
+    // 3 control Int32s
+    this._controlBuf = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 3);
+    this._control = new Int32Array(this._controlBuf);
+    
+    // 1MB data buffer (should be enough for template substitutions and function returns)
+    this._dataBuf = new SharedArrayBuffer(1024 * 1024);
+    this._dataView = new Uint8Array(this._dataBuf);
+    this._textDecoder = new TextDecoder();
+  }
+
+  _executeSyncWorker(workerDataPayload) {
+    if (!this._mainScriptPath) {
+      throw new Error("Could not determine main script path. Ensure process.argv[1] is set.");
+    }
+
+    // Set lock to busy (1)
+    Atomics.store(this._control, CONTROL_INDICES.STATUS, 1);
+
+    const worker = new Worker(workerPath, {
+      workerData: {
+        ...workerDataPayload,
+        mainScriptPath: globalThis.__gasFakesMainScriptPath || this._mainScriptPath,
+        controlBuf: this._controlBuf,
+        dataBuf: this._dataBuf,
+        env: process.env // Pass current environment
+      },
+      stdout: true,
+      stderr: true
+    });
+
+    worker.stdout.pipe(process.stdout);
+    worker.stderr.pipe(process.stderr);
+
+    // Handle unexpected worker crashes
+    worker.on('error', (err) => {
+      console.error("Consumer worker crashed:", err);
+      Atomics.store(this._control, CONTROL_INDICES.STATUS, 0);
+      Atomics.notify(this._control, 0);
+    });
+    
+    worker.on('exit', (code) => {
+      if (code !== 0) {
+        Atomics.store(this._control, CONTROL_INDICES.STATUS, 0);
+        Atomics.notify(this._control, 0);
+      }
+    });
+
+    // Block main thread until worker finishes (sets status to 0)
+    Atomics.wait(this._control, CONTROL_INDICES.STATUS, 1);
+
+    // Read result
+    const hasError = Atomics.load(this._control, CONTROL_INDICES.IS_ERROR) === 1;
+    const resultSize = Atomics.load(this._control, CONTROL_INDICES.DATA_SIZE);
+    
+    const resultBytes = this._dataView.slice(0, resultSize);
+    const resultString = this._textDecoder.decode(resultBytes);
+    
+    const resultData = JSON.parse(resultString);
+
+    if (hasError) {
+      // If the error was thrown as a string, its stack will be artificial (generated in writeError)
+      // and won't contain the actual message. Let's make sure the message is always visible.
+      const errorMsg = resultData.message || 'Unknown error in worker';
+      const errorStack = resultData.stack || '';
+      
+      const err = new Error(errorMsg);
+      // Only replace the stack if it contains useful information, otherwise use the standard one
+      if (errorStack && !errorStack.startsWith('Error\n    at writeError')) {
+        err.stack = errorStack;
+      }
+      throw err;
+    }
+
+    return resultData;
+  }
+
+  /**
+   * Synchronously evaluates a template string in a fresh consumer instance.
+   */
+  evaluateTemplate(templateString) {
+    return this._executeSyncWorker({
+      isTemplate: true,
+      templateString
+    });
+  }
+
+  /**
+   * Synchronously executes a function in a fresh consumer instance.
+   */
+  runFunction(funcName, args) {
+    return this._executeSyncWorker({
+      isTemplate: false,
+      funcName,
+      args
+    });
+  }
+}