@mcpher/gas-fakes 2.5.3 → 2.5.5

package/src/services/urlfetchapp/app.js

@@ -1,217 +1,258 @@
 // fake Apps Script UrlFetchApp
 
-import { Auth } from '../../support/auth.js'
 import { Syncit } from '../../support/syncit.js'
 import { Proxies } from '../../support/proxies.js'
 
-// Note that all async type functions have been converted to synch ro make it Apps Script like
-
-
 /**
- * make got response look like UrlFetchApp response
- * @param {Response} reponse
- * @return {FakeHTTPResponse} UrlFetchApp flavor 
+ * Helper function to fix and normalize HTTP headers.
+ * @param {object} response - The raw response object.
+ * @returns {object} Normalized headers object.
  */
-const responsify = (response) => {
-  if (!response) {
-    // Return a dummy response that identifies as an error
-    return {
-      getAllHeaders: () => ({}),
-      getResponseCode: () => 500,
-      getContentText: () => "UrlFetchApp: No response data available.",
-      getHeaders: () => ({}),
-      getBlob: () => null,
-      getContent: () => []
-    }
+const fixHeaders = (response) => {
+  // it's a map with a pair of values
+  const headers = (response.rawHeaders || [])
+  if (headers.length % 2 !== 0) {
+    throw `fixHeaders:invalid number of header value pairs - ${headers.length}`
   }
+  // split into pairs and return as object
+  const mapHeaders = new Map(headers.flatMap((_, i, a) => i % 2 ? [] : [a.slice(i, i + 2)]));
+  return Object.fromEntries(mapHeaders)
+}
 
-  // getAllHeaders()	Object	Returns an attribute/value map of headers for the HTTP response, with headers that have multiple values returned as arrays.
-  const getAllHeaders = () => fixHeaders(response)
+/**
+ * Helper function to convert raw response data into a FakeBlob.
+ * Assumes Utilities.newBlob is available in the scope.
+ * @param {object} response - The raw response object.
+ * @param {object} headers - The normalized headers.
+ * @returns {object} A FakeBlob representation.
+ */
+const blobify = (response, headers) => {
+  if (!headers) return null
+  // the name is buried in the Conent-Disposition
+  const disp = headers["Content-Disposition"]
+  const filename = disp && disp.replace(/.*filename="([^"]*).*/, "$1")
+  const name = filename || ""
+  const contentType = headers["Content-Type"]?.replace(/([^;]*).*/, "$1").trim()
+  const bytes = response.rawBody || response.body || null
+  // Assuming Utilities is available globally or imported elsewhere
+  return Utilities.newBlob(bytes, contentType, name)
+}
 
-  // getResponseCode()	Integer	Get the HTTP status code (200 for OK, etc.) of an HTTP response
-  const getResponseCode = () => response.statusCode || response.status || 500
 
-  // getContentText()	String	Gets the content of an HTTP response encoded as a string.
-  const getContentText = () => blobify(response).getDataAsString()
+/**
+ * Represents a fake HTTP response object, mimicking UrlFetchApp's response structure.
+ */
+export class FakeHTTPResponse {
+  /**
+   * @param {object} response - The raw response data from Syncit.
+   */
+  constructor(response) {
+    this._response = response
+    this._headers = null
+  }
 
-  // getHeaders()	Object	Returns an attribute/value map of headers for the HTTP response.
-  const getHeaders = () => fixHeaders(response)
+  /**
+   * @returns {object} Attribute/value map of headers.
+   */
+  getAllHeaders() {
+    if (!this._response) return {}
+    if (!this._headers) {
+      this._headers = fixHeaders(this._response)
+    }
+    return this._headers
+  }
 
-  // getContent() Bytes[] the data as byte array
-  const getContent = () => response.rawBody || response.body
+  /**
+   * @returns {number} The HTTP status code.
+   */
+  getResponseCode() {
+    if (!this._response) return 500
+    return this._response.statusCode || this._response.status || 500
+  }
 
-  // getBlob () FakeBlob the content as a blob
-  const getBlob = () => blobify(response)
+  /**
+   * @returns {string} The content of an HTTP response encoded as a string.
+   */
+  getContentText() {
+    if (!this._response) return "UrlFetchApp: No response data available."
+    const headers = this.getAllHeaders()
+    const blob = blobify(this._response, headers)
+    return blob ? blob.getDataAsString() : ""
+  }
 
-  // got returns lower case headers props, so we have to resort to using rawheaders so we match the case of Apps Script
-  // TODO - find an example in apps script where getAllHeaders is not equal to getHeaders
-  const fixHeaders = (response) => {
-    // it's a map with a pair of values
-    const headers = (response.rawHeaders || [])
-    if (headers % 2) {
-      throw `fixHeaders:invalid number of header value pairs - ${headers.length}`
-    }
-    // split into pairs and return as object
-    const mapHeaders = new Map(headers.flatMap((_, i, a) => i % 2 ? [] : [a.slice(i, i + 2)]));
-    return Object.fromEntries(mapHeaders)
+  /**
+   * @returns {object} Attribute/value map of headers.
+   */
+  getHeaders() {
+    return this.getAllHeaders()
   }
-  const blobify = (response) => {
-    const headers = fixHeaders(response)
-    if (!headers) return null
-    // the name is buried in the Conent-Disposition
-    const disp = headers["Content-Disposition"]
-    const filename = disp && disp.replace(/.*filename="([^"]*).*/, "$1")
-    const name = filename || ""
-    const contentType = headers["Content-Type"]?.replace(/([^;]*).*/, "$1").trim()
-    const bytes = response.rawBody || response.body || null
-    return Utilities.newBlob(bytes, contentType, name)
+
+  /**
+   * @returns {ArrayBuffer | Uint8Array} The raw binary content of an HTTP response.
+   */
+  getContent() {
+    if (!this._response) return []
+    return this._response.rawBody || this._response.body
   }
 
-  /* TODO
-  getAs(contentType)	Blob	Return the data inside this object as a blob converted to the specified content type.
-  getBlob()	Blob	Return the data inside this object as a blob.
-  getContent()	Byte[]	Gets the raw binary content of an HTTP response.
-  getContentText(charset)	String	Returns the content of an HTTP response encoded as a string of the given charset.
-  */
-  return {
-    getAllHeaders,
-    getResponseCode,
-    getContentText,
-    getHeaders,
-    getBlob,
-    getContent
+  /**
+   * @returns {object} A FakeBlob representing the content.
+   */
+  getBlob() {
+    if (!this._response) return null
+    const headers = this.getAllHeaders()
+    return blobify(this._response, headers)
   }
 }
 
-// this has been syncified
-const fetch = (url, options = {}) => {
+/**
+ * Represents a fake UrlFetchApp service, mimicking the global Apps Script service.
+ */
+export class FakeUrlFetchApp {
+  /**
+   * @param {object} [options] - Configuration options (optional).
+   */
+  constructor(options = {}) {
+    this.options = options
+  }
 
-  // check options for method and provide default
-  options.method = options.method || "get"
+  /**
+   * Performs a GET request.
+   * @param {string} url - The URL to fetch.
+   * @param {object} [options] - Request options.
+   * @returns {FakeHTTPResponse} The response object.
+   */
+  fetch(url, options = {}) {
+    // check options for method and provide default
+    options.method = options.method || "get"
 
-  const responseFields = [
-    'rawHeaders',
-    'statusCode',
-    'body',
-    'headers',
-    'rawBody'
-  ]
+    const responseFields = [
+      'rawHeaders',
+      'statusCode',
+      'body',
+      'headers',
+      'rawBody'
+    ]
 
-  const { data } = Syncit.fxFetch(url, options, responseFields)
-  return responsify(data)
-}
+    const { data } = Syncit.fxFetch(url, options, responseFields)
+    return new FakeHTTPResponse(data)
+  }
 
-// this has been syncified
-const fetchAll = (requests) => {
+  /**
+   * Performs multiple requests concurrently.
+   * @param {Array<object>} requests - Array of request configurations.
+   * @returns {Array<FakeHTTPResponse>} Array of response objects.
+   */
+  fetchAll(requests) {
+    const responseFields = [
+      'rawHeaders',
+      'statusCode',
+      'body',
+      'headers',
+      'rawBody'
+    ]
 
-  const responseFields = [
-    'rawHeaders',
-    'statusCode',
-    'body',
-    'headers',
-    'rawBody'
-  ]
+    const responses = Syncit.fxFetchAll(requests, responseFields)
+    return responses.map(({ data }) => new FakeHTTPResponse(data))
+  }
 
-  const responses = Syncit.fxFetchAll(requests, responseFields)
-  return responses.map(({ data }) => responsify(data))
-}
+  /**
+   * Generates a standardized request object for UrlFetchApp.
+   * @param {string} url - The target URL.
+   * @param {object} [options] - Request options.
+   * @returns {object} The standardized request object.
+   */
+  getRequest(url, options = {}) {
+    const defaultMethod = 'get';
+    const request = {
+      url: url,
+      method: (options.method || defaultMethod).toLowerCase(),
+      headers: options.headers || {},
+    };
 
-const getRequest = (url, options = {}) => {
-  const defaultMethod = 'get';
-  const request = {
-    url: url,
-    method: (options.method || defaultMethod).toLowerCase(),
-    headers: options.headers || {},
-  };
-
-  // Apps Script defaults
-  if (options.contentType) {
-    request.contentType = options.contentType;
-  }
-  
-  if (options.payload) {
-    request.payload = options.payload;
-  }
-  
-  if (options.useIntranet !== undefined) {
-    request.useIntranet = options.useIntranet;
-  }
+    // Apps Script defaults
+    if (options.contentType) {
+      request.contentType = options.contentType;
+    }
 
-  // Add standard fetch behavior
-  if (request.method === 'post' || request.method === 'put' || request.method === 'patch') {
-     if (!request.contentType) {
-       request.contentType = 'application/x-www-form-urlencoded';
-     }
-  }
+    if (options.payload !== undefined && options.payload !== null) {
+      const payload = options.payload;
 
-  return request;
+      // 1. Handle Blob payload
+      if (typeof payload.getDataAsString === 'function') {
+        request.payload = payload.getDataAsString();
+      }
+      // 2. Handle Byte[] array payload (Array of numbers)
+      else if (Array.isArray(payload) && payload.every(item => typeof item === 'number')) {
+        // Convert byte array to UTF-8 string
+        request.payload = Buffer.from(payload).toString('utf8');
+      }
+      // 3. Handle plain JavaScript object payload
+      else if (typeof payload === 'object' && !Buffer.isBuffer(payload)) {
+        // Serialize object to form-encoded string
+        const params = new URLSearchParams();
+        for (const key in payload) {
+          if (Object.prototype.hasOwnProperty.call(payload, key)) {
+            params.append(key, payload[key]);
+          }
+        }
+        request.payload = params.toString();
+        
+        // Set default content type for form data
+        if (!request.contentType) {
+          request.contentType = 'application/x-www-form-urlencoded';
+        }
+      }
+      // Default case: pass payload directly (e.g., string, Buffer, etc.)
+      else {
+        request.payload = payload;
+      }
+    } else if (options.payload === null) {
+      request.payload = null;
+    }
+
+    if (options.useIntranet !== undefined) {
+      request.useIntranet = options.useIntranet;
+    }
+
+    // Add standard fetch behavior
+    if (request.method === 'post' || request.method === 'put' || request.method === 'patch') {
+      if (!request.contentType) {
+        request.contentType = 'application/x-www-form-urlencoded';
+      }
+    }
+
+    return request;
+  }
 }
 
+/**
+ * Helper function to create and return a new instance of FakeUrlFetchApp.
+ * @returns {FakeUrlFetchApp}
+ */
+export const newFakeUrlFetchApp = () => new FakeUrlFetchApp();
+
 
 // This will eventually hold a proxy for DriveApp
 let _app = null
 
 /**
- * adds to global space to mimic Apps Script behavior
+ * Gets the singleton instance of FakeUrlFetchApp.
+ * @returns {FakeUrlFetchApp}
  */
-const name = "UrlFetchApp"
-if (typeof globalThis[name] === typeof undefined) {
-
-  const getApp = () => {
-    // if it hasne been intialized yet then do that
-    if (!_app) {
-      _app = {
-        fetch,
-        fetchAll,
-        getRequest
-      }
-    }
-    // this is the actual driveApp we'll return from the proxy
-    return _app
+const getApp = () => {
+  // if it hasn't been initialized yet then do that
+  if (!_app) {
+    _app = newFakeUrlFetchApp()
   }
+  // return the actual driveApp we'll return from the proxy
+  return _app
+}
 
+/**
+ * Adds to global space to mimic Apps Script behavior
+ */
+const name = "UrlFetchApp"
+if (typeof globalThis[name] === typeof undefined) {
   Proxies.registerProxy(name, getApp)
-
 }
-
-
-/** got reponse props
-  [ '_events', 'object' ],
-  [ '_readableState', 'object' ],
-  [ '_writableState', 'object' ],
-  [ 'allowHalfOpen', 'boolean' ],
-  [ '_destroy', 'function' ],
-  [ '_maxListeners', 'undefined' ],
-  [ '_eventsCount', 'number' ],
-  [ 'socket', 'object' ],
-  [ 'httpVersionMajor', 'number' ],
-  [ 'httpVersionMinor', 'number' ],
-  [ 'httpVersion', 'string' ],
-  [ 'complete', 'boolean' ],
-  [ 'rawHeaders', 'object' ],
-  [ 'rawTrailers', 'object' ],
-  [ 'joinDuplicateHeaders', 'undefined' ],
-  [ 'aborted', 'boolean' ],
-  [ 'upgrade', 'boolean' ],
-  [ 'url', 'string' ],
-  [ 'method', 'object' ],
-  [ 'statusCode', 'number' ],
-  [ 'statusMessage', 'string' ],
-  [ 'client', 'object' ],
-  [ '_consuming', 'boolean' ],
-  [ '_dumped', 'boolean' ],
-  [ 'req', 'object' ],
-  [ 'timings', 'object' ],
-  [ 'headers', 'object' ],
-  [ 'setTimeout', 'function' ],
-  [ 'trailers', 'object' ],
-  [ 'requestUrl', 'object' ],
-  [ 'redirectUrls', 'object' ],
-  [ 'request', 'object' ],
-  [ 'isFromCache', 'boolean' ],
-  [ 'ip', 'string' ],
-  [ 'retryCount', 'number' ],
-  [ 'ok', 'boolean' ],
-  [ 'rawBody', 'object' ],
-  [ 'body', 'string' ]
- */

package/src/services/xmlservice/app.js

@@ -1,81 +1,6 @@
 // fake Apps Script XmlService
-import { XMLParser } from 'fast-xml-parser';
-import { Proxies } from '../../support/proxies.js';
-import { FakeDocument } from './fakedocument.js';
-import { FakeElement } from './fakeelement.js';
-import { FakeNamespace } from './fakenamespace.js';
-import { FakeFormat } from './fakeformat.js';
+import { newFakeXmlService as maker } from './fakexmlservice.js';
+import { lazyLoaderApp } from '../common/lazyloader.js';
 
-/**
- * Parses the given XML string and returns a Document object.
- * @param {string} xml The XML string to parse.
- * @return {FakeDocument} The parsed document.
- */
-const parse = (xml) => {
-  const options = {
-    ignoreAttributes: false,
-    attributeNamePrefix: "@_",
-    textNodeName: "#text",
-    alwaysCreateTextNode: true,
-    removeNSPrefix: false // We need prefixes to map them in FakeElement
-  };
-  const parser = new XMLParser(options);
-  const jsonObj = parser.parse(xml);
-
-  // The jsonObj will have the root element name as a key
-  const rootName = Object.keys(jsonObj).find(key => !key.startsWith('?')); // Ignore processing instructions
-  if (!rootName) {
-    throw new Error("XmlService: No root element found in XML.");
-  }
-
-  const rootData = jsonObj[rootName];
-  const rootElement = new FakeElement(rootName, rootData);
-  return new FakeDocument(rootElement);
-};
-
-/**
- * Returns a Namespace object with the given prefix and URI.
- * @param {string} prefix The prefix.
- * @param {string} uri The URI.
- * @return {FakeNamespace} The namespace.
- */
-const getNamespace = (prefix, uri) => {
-  return new FakeNamespace(prefix, uri);
-};
-
-/**
- * Returns a Format object for pretty printing.
- * @return {FakeFormat} The format object.
- */
-const getPrettyFormat = () => {
-  return new FakeFormat({ pretty: true });
-};
-
-/**
- * Returns a Format object for raw output.
- * @return {FakeFormat} The format object.
- */
-const getRawFormat = () => {
-  return new FakeFormat({ pretty: false });
-};
-
-// Singleton app object
 let _app = null;
-
-const name = "XmlService";
-if (typeof globalThis[name] === typeof undefined) {
-  const getApp = () => {
-    if (!_app) {
-      _app = {
-        parse,
-        getNamespace,
-        getPrettyFormat,
-        getRawFormat,
-        toString: () => name
-      };
-    }
-    return _app;
-  };
-
-  Proxies.registerProxy(name, getApp);
-}
+_app = lazyLoaderApp(_app, 'XmlService', maker);

package/src/services/xmlservice/fakeattribute.js

@@ -0,0 +1,15 @@
+import { FakeNamespace } from './fakenamespace.js';
+
+export class FakeAttribute {
+  constructor(name, value, namespace = null) {
+    this._name = name;
+    this._value = value;
+    this._namespace = namespace || new FakeNamespace("", "");
+  }
+  getName() { return this._name; }
+  getValue() { return this._value; }
+  getNamespace() { return this._namespace; }
+  setName(name) { this._name = name; return this; }
+  setValue(value) { this._value = value; return this; }
+  setNamespace(namespace) { this._namespace = namespace; return this; }
+}

package/src/services/xmlservice/fakecdata.js

@@ -0,0 +1,40 @@
+import { FakeContent } from './fakecontent.js';
+import * as Enums from '../enums/xmlenums.js';
+
+export class FakeCdata extends FakeContent {
+  constructor(text, parentElement = null) {
+    super(Enums.ContentTypes.CDATA);
+    this._text = text || '';
+    this._parent = parentElement;
+  }
+
+  append(text) {
+    this._text += text || '';
+    return this;
+  }
+
+  getText() {
+    return this._text;
+  }
+
+  getValue() {
+    return this._text;
+  }
+
+  setText(text) {
+    this._text = text || '';
+    return this;
+  }
+
+  detach() {
+    return super.detach();
+  }
+
+  getParentElement() {
+    return super.getParentElement();
+  }
+
+  toString() {
+    return `[CDATA: ${this._text}]`;
+  }
+}

package/src/services/xmlservice/fakecomment.js

@@ -0,0 +1,34 @@
+import { FakeContent } from './fakecontent.js';
+import * as Enums from '../enums/xmlenums.js';
+
+export class FakeComment extends FakeContent {
+  constructor(text = '') {
+    super(Enums.ContentTypes.COMMENT);
+    this._text = text;
+  }
+
+  getText() {
+    return this._text;
+  }
+
+  setText(text) {
+    this._text = text || '';
+    return this;
+  }
+
+  getValue() {
+    return this._text;
+  }
+
+  detach() {
+    return super.detach();
+  }
+
+  getParentElement() {
+    return super.getParentElement();
+  }
+
+  toString() {
+    return `[Comment: <!--${this._text}-->]`;
+  }
+}

package/src/services/xmlservice/fakecontent.js

@@ -0,0 +1,51 @@
+import * as Enums from '../enums/xmlenums.js';
+
+/**
+ * Base class for all XML content nodes (Text, Element, Comment, etc.).
+ * Provides core functionality for content representation and type casting.
+ */
+export class FakeContent {
+  /**
+   * @param {string} type - The content type of this node.
+   */
+  constructor(type) {
+    this._type = type;
+    this._parent = null;
+  }
+
+  getType() {
+    return this._type;
+  }
+
+  getParentElement() {
+    if (this._parent && this._parent.constructor && this._parent.constructor.name === 'FakeDocument') {
+      return null;
+    }
+    return this._parent;
+  }
+
+  setParentElement(parent) {
+    this._parent = parent;
+  }
+
+  detach() {
+    if (this._parent && typeof this._parent.removeContent === 'function') {
+      this._parent.removeContent(this);
+    }
+    this._parent = null;
+    return this;
+  }
+
+  // --- Type Casting Methods ---
+  asCdata() { return this._type === Enums.ContentTypes.CDATA ? this : null; }
+  asComment() { return this._type === Enums.ContentTypes.COMMENT ? this : null; }
+  asDocType() { return this._type === Enums.ContentTypes.DOCTYPE ? this : null; }
+  asElement() { return this._type === Enums.ContentTypes.ELEMENT ? this : null; }
+  asEntityRef() { return this._type === Enums.ContentTypes.ENTITYREF ? this : null; }
+  asProcessingInstruction() { return this._type === Enums.ContentTypes.PROCESSINGINSTRUCTION ? this : null; }
+  asText() { return this._type === Enums.ContentTypes.TEXT ? this : null; }
+
+  getValue() {
+    return '';
+  }
+}