@mcpher/gas-fakes 1.2.32 → 2.0.1

package/src/support/sxdrive.js

@@ -7,92 +7,35 @@
  */
 
 import { responseSyncify } from './auth.js';
+import { sxRetry } from './sxretry.js';
 import intoStream from 'into-stream';
 import { getStreamAsBuffer } from 'get-stream';
 import { syncWarn, syncError, syncLog } from './workersync/synclogger.js';
 import { getDriveApiClient } from '../services/advdrive/drapis.js';
 import { translateFieldsToV2 } from './utils.js';
 
-
-/**
- * serializable reponse from a sync call
- * @typedef SxResponse
- * @property {number} status
- * @property {string} statusText
- * @property {string} responseUrl
- * @property {boolean} fromCache
- */
-
-/**
- * what's eventually returned from the sync call
- * @typedef SxResult
- * @property {*} data the data from the api call
- * @property {SxResponse} reponse the response from the api call
- */
-
-/**
- * serialized blob
- * @typedef SerializedBlob 
- * @property {string} name
- * @property {byte[]} bytes 
- */
-
-
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-
 export const sxDrive = async (Auth, { prop, method, params, options }) => {
 
   const apiClient = getDriveApiClient();
-  //syncLog(JSON.stringify ({ prop, method, params, options }))
-  const maxRetries = 7;
-  let delay = 1777;
-
-  for (let i = 0; i < maxRetries; i++) {
-    let response;
-    let error;
-
-    try {
-      const callish = apiClient[prop];
-      response = await callish[method](params, options);
-    } catch (err) {
-      error = err;
-      response = err.response;
+  const tag = `sxDrive for ${prop}.${method}`;
+
+  return sxRetry(Auth, tag, async () => {
+    return apiClient[prop][method](params, options);
+  }, {
+    extraRetryCheck: (error, response) => {
+      // handle invalid field selection - sometimes old files dont support createdTime or modifiedTime
+      // we'll try to fallback to createdDate and modifiedDate
+      const isInvalidField = error?.message?.includes("Invalid field selection") && (params?.fields?.includes("createdTime") || params?.fields?.includes("modifiedTime"));
+
+      if (isInvalidField) {
+        const fileId = params?.fileId ? ` for file ${params.fileId}` : "";
+        syncWarn(`Invalid field selection error on Drive API call ${prop}.${method}${fileId}. Retrying with v2 field names...`);
+        params.fields = translateFieldsToV2(params.fields);
+        return true;
+      }
+      return false;
     }
-
-    const isRetryable = [429, 500, 503].includes(response?.status) || error?.code == 429;
-
-    // handle invalid field selection - sometimes old files dont support createdTime or modifiedTime
-    // we'll try to fallback to createdDate and modifiedDate
-    const isInvalidField = error?.message?.includes("Invalid field selection") && (params?.fields?.includes("createdTime") || params?.fields?.includes("modifiedTime"));
-
-    if (isInvalidField && i < maxRetries - 1) {
-      const fileId = params?.fileId ? ` for file ${params.fileId}` : "";
-      syncWarn(`Invalid field selection error on Drive API call ${prop}.${method}${fileId}. Retrying with v2 field names...`);
-      params.fields = translateFieldsToV2(params.fields);
-      continue;
-    }
-
-    if (isRetryable && i < maxRetries - 1) {
-      // add a random jitter to avoid thundering herd
-      const jitter = Math.floor(Math.random() * 1000);
-      syncWarn(`Retryable error on Drive API call ${prop}.${method} (status: ${response?.status}). Retrying in ${delay + jitter}ms...`);
-      await sleep(delay + jitter);
-      delay *= 2;
-      continue;
-    }
-
-    if (error || isRetryable) {
-      syncError(`Failed in sxDrive for ${prop}.${method}`, error);
-      return {
-        data: null,
-        response: responseSyncify(response)
-      };
-    }
-    return {
-      data: response.data,
-      response: responseSyncify(response)
-    };
-  }
+  });
 };
 
 /**

package/src/support/sxfetch.js

@@ -1,9 +1,4 @@
-/**
- * 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 { sxRetry } from './sxretry.js';
 import got from 'got';
 
 
@@ -42,34 +37,45 @@ const fixOptions = (options) => {
  * @returns {object} an http type response
  */
 export const sxFetch = async (Auth, url, options, responseFields) => {
-  // we need special headers if we're calling google apis
-  options = Auth.googify(options)
 
-  // Always fetch as a buffer to prevent corruption of binary data like images.
-  // The caller (UrlFetchApp/HttpResponse) will be responsible for decoding to text if needed.
-  const fixedOptions = fixOptions(options)
+  const tag = `sxFetch for ${url}`;
 
-  const response = await got(url, {
-    ...fixedOptions,
-    responseType: 'buffer'
-  })
+  return sxRetry(Auth, tag, async () => {
+    // we need special headers if we're calling google apis
+    // notably, the token might be refreshed on retry, so googify must be inside
+    const googOptions = Auth.googify(options)
 
-  // we cant return the response from this as it cant be serialized
-  // so we;ll extract oout the fields required
-  const result = responseFields.reduce((p, c) => {
-    p[c] = response[c]
-    return p
-  }, {})
+    // Always fetch as a buffer to prevent corruption of binary data like images.
+    // The caller (UrlFetchApp/HttpResponse) will be responsible for decoding to text if needed.
+    const fixedOptions = fixOptions(googOptions)
 
-  // The rawBody is a Buffer. Convert it to a byte array for proper serialization across the worker boundary.
-  if (result.rawBody) {
-    result.rawBody = Array.from(result.rawBody);
-  }
-  // The body will also be a buffer
-  if (result.body && Buffer.isBuffer(result.body)) {
-    result.body = Array.from(result.body);
-  }
-  return result;
+    const response = await got(url, {
+      ...fixedOptions,
+      responseType: 'buffer'
+    })
+
+    // we cant return the response from this as it cant be serialized
+    // so we;ll extract oout the fields required
+    const result = responseFields.reduce((p, c) => {
+      p[c] = response[c]
+      return p
+    }, {})
+
+    // The rawBody is a Buffer. Convert it to a byte array for proper serialization across the worker boundary.
+    if (result.rawBody) {
+      result.rawBody = Array.from(result.rawBody);
+    }
+    // The body will also be a buffer
+    if (result.body && Buffer.isBuffer(result.body)) {
+      result.body = Array.from(result.body);
+    }
+    // we return what sxRetry expects: an object with data and response (or just the object if it's the result)
+    // Actually sxRetry expects the result of the func to have .data and .response or it will use the result itself.
+    // sxFetch returns the result fields directly in the GAS implementation.
+    // Let's wrap it for sxRetry
+    return { data: result, response };
+
+  });
 }
 
 /**

package/src/support/sxforms.js

@@ -6,51 +6,20 @@
  * - arguments and returns must be serializable ie. primitives or plain objects
  */
 
-import { responseSyncify } from './auth.js';
-import { syncWarn, syncError, syncLog } from './workersync/synclogger.js';
+import { sxRetry } from './sxretry.js';
 import { getFormsApiClient } from '../services/advforms/formsapis.js';
 
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-
 export const sxForms = async (Auth, { prop, subProp, method, params, options = {} }) => {
 
   const apiClient = getFormsApiClient();
+  const tag = `sxForms for ${prop}${subProp ? '.' + subProp : ''}.${method}`;
 
-  const maxRetries = 7;
-  let delay = 1777;
-  // syncLog(`Forms API Call: ${prop}${subProp ? '.' + subProp : ''}.${method}, Params: ${JSON.stringify(params)}`);
-  for (let i = 0; i < maxRetries; i++) {
-    let response;
-    let error;
-
-    try {
-      // Access the base property (e.g., 'forms'), then the sub-property if it exists (e.g., 'responses').
-      let callish = apiClient[prop];
-      if (subProp) {
-        callish = callish[subProp];
-      }
-      response = await callish[method](params, options);
-      //syncLog(`Forms API Response: ${prop}${subProp ? '.' + subProp : ''}.${method}, Status: ${response?.status}, Data: ${JSON.stringify(response?.data)}`);
-    } catch (err) {
-      error = err;
-      response = err.response;
-      syncError(`Forms API Error Response: ${prop}${subProp ? '.' + subProp : ''}.${method}, Status: ${response?.status}, Error: ${JSON.stringify(error)}`);
-    }
-
-    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 Forms API call ${prop}${subProp ? '.' + subProp : ''}.${method} (status: ${response?.status}). Retrying in ${delay + jitter}ms...`);
-      await sleep(delay + jitter);
-      delay *= 2;
-      continue;
-    }
-
-    if (error || isRetryable) {
-      syncError(`Failed in sxForms for ${prop}${subProp ? '.' + subProp : ''}.${method}`, error);
-      return { data: null, response: responseSyncify(response) };
+  return sxRetry(Auth, tag, async () => {
+    // Access the base property (e.g., 'forms'), then the sub-property if it exists (e.g., 'responses').
+    let callish = apiClient[prop];
+    if (subProp) {
+      callish = callish[subProp];
     }
-    return { data: response.data, response: responseSyncify(response) };
-  }
+    return callish[method](params, options);
+  });
 };

package/src/support/sxgmail.js

@@ -6,51 +6,23 @@
  * - arguments and returns must be serializable ie. primitives or plain objects
  */
 
-import { responseSyncify } from './auth.js';
-import { syncWarn, syncError } from './workersync/synclogger.js';
+import { sxRetry } from './sxretry.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}`;
+  const tag = `sxGmail for ${methodName}`;
 
-  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) {
+  return sxRetry(Auth, tag, async () => {
+    const callish = subProp ? apiClient[prop][subProp] : apiClient[prop];
+    return callish[method](params, options);
+  }, {
+    skipLog: (error, response) => {
       // Don't log 404, 409, or 400 as an error. 
       // 400 (Invalid delete request) happens when we try to delete an ID as a label but it's not a label.
-      if (response?.status !== 404 && response?.status !== 409 && response?.status !== 400) {
-        syncError(`Failed in sxGmail for ${methodName}`, error);
-      }
-      return { data: null, response: responseSyncify(response) };
+      return response?.status === 404 || response?.status === 409 || response?.status === 400;
     }
-    return {
-      data: response.data,
-      response: responseSyncify(response)
-    };
-  }
+  });
 };

package/src/support/sxretry.js

@@ -0,0 +1,79 @@
+import { responseSyncify } from './auth.js';
+import { syncWarn, syncError } from './workersync/synclogger.js';
+
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+/**
+ * Shared retry logic for worker-based API calls
+ * @param {object} Auth the Auth object
+ * @param {string} tag for logging
+ * @param {function} func the function to execute
+ * @param {object} [options] options
+ * @param {number} [options.maxRetries=7] max retries
+ * @param {number} [options.initialDelay=1777] initial delay
+ * @param {function} [options.extraRetryCheck] extra check for retryability
+ * @param {function} [options.skipLog] check to skip syncError logging
+ * @returns {object} { data, response }
+ */
+export const sxRetry = async (Auth, tag, func, options = {}) => {
+  const {
+    maxRetries = 7,
+    initialDelay = 1777,
+    extraRetryCheck = () => false,
+    skipLog = () => false
+  } = options;
+
+  let delay = initialDelay;
+
+  for (let i = 0; i < maxRetries; i++) {
+    let response;
+    let error;
+
+    try {
+      response = await func();
+    } catch (err) {
+      error = err;
+      response = err.response;
+    }
+
+    const redoCodes = [429, 500, 503, 408, 401]
+    const isRetryable = redoCodes.includes(error?.code) ||
+      redoCodes.includes(response?.status) ||
+      error?.code === 'ETIMEDOUT' ||
+      error?.code === 'ECONNRESET' ||
+      error?.cause?.code === 'ETIMEDOUT' ||
+      error?.cause?.code === 'ECONNRESET' ||
+      error?.message?.includes('ETIMEDOUT') ||
+      error?.message?.includes('ECONNRESET') ||
+      (response?.status === 403 && (
+        error?.message?.toLowerCase().includes('usage limit') ||
+        error?.message?.toLowerCase().includes('rate limit') ||
+        error?.errors?.some(e => ['rateLimitExceeded', 'userRateLimitExceeded', 'calendarUsageLimitsExceeded'].includes(e.reason))
+      )) ||
+      extraRetryCheck(error, response);
+
+    if (isRetryable && i < maxRetries - 1) {
+      const isAuthError = error?.code === 401 || response?.status === 401;
+      if (isAuthError) {
+        Auth.invalidateToken();
+        syncWarn(`Authentication error (401) on ${tag}. Invalidated token and retrying immediately...`);
+      } else {
+        const jitter = Math.floor(Math.random() * 1000);
+        const totalDelay = delay + jitter;
+        syncWarn(`Retryable error on ${tag} (status: ${response?.status || error?.code}). Retrying in ${totalDelay}ms...`);
+        await sleep(totalDelay);
+        delay *= 2;
+      }
+      continue;
+    }
+
+    if (error) {
+      if (!skipLog(error, response)) {
+        syncError(`Failed in ${tag}`, error);
+      }
+      return { data: null, response: responseSyncify(response) };
+    }
+
+    return { data: response.data, response: responseSyncify(response) };
+  }
+};

package/src/support/sxsheets.js

@@ -6,47 +6,16 @@
  * - arguments and returns must be serializable ie. primitives or plain objects
  */
 
-import { responseSyncify } from './auth.js';
-import { syncWarn, syncError } from './workersync/synclogger.js';
+import { sxRetry } from './sxretry.js';
 import { getSheetsApiClient } from '../services/advsheets/shapis.js';
 
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-
 export const sxSheets = async (Auth, { subProp, prop, method, params, options }) => {
 
   const apiClient = getSheetsApiClient();
-  const maxRetries = 7;
-  let delay = 1777;
-
-  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) {
-      // add a random jitter to avoid thundering herd
-      const jitter = Math.floor(Math.random() * 1000);
-      syncWarn(`Retryable error on Sheets API call ${prop}.${method} (status: ${response?.status}). Retrying in ${delay + jitter}ms...`);
-      await sleep(delay + jitter);
-      delay *= 2;
-      continue;
-    }
+  const tag = `sxSheets for ${prop}.${method}`;
 
-    if (error || isRetryable) {
-      syncError(`Failed in sxSheets for ${prop}.${method}`, error);
-      return { data: null, response: responseSyncify(response) };
-    }
-    return {
-      data: response.data,
-      response: responseSyncify(response)
-    };
-  }
+  return sxRetry(Auth, tag, async () => {
+    const callish = subProp ? apiClient[prop][subProp] : apiClient[prop];
+    return callish[method](params, options);
+  });
 };

package/src/support/sxslides.js

@@ -6,12 +6,9 @@
  * - arguments and returns must be serializable ie. primitives or plain objects
  */
 
-import { responseSyncify } from './auth.js';
-import { syncWarn, syncError } from './workersync/synclogger.js';
+import { sxRetry } from './sxretry.js';
 import { getSlidesApiClient } from '../services/advslides/slapis.js';
 
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-
 /**
  * sync a call to slides api
  * @param {object} Auth the auth object
@@ -25,37 +22,9 @@ const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 export const sxSlides = async (Auth, { prop, method, params, options = {} }) => {
 
   const apiClient = getSlidesApiClient();
+  const tag = `sxSlides for ${prop}.${method}`;
 
-  const maxRetries = 7;
-  let delay = 1777;
-
-  for (let i = 0; i < maxRetries; i++) {
-    let response;
-    let error;
-
-    try {
-      const callish = 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) {
-      // add a random jitter to avoid thundering herd
-      const jitter = Math.floor(Math.random() * 1000);
-      syncWarn(`Retryable error on Slides API call ${prop}.${method} (status: ${response?.status}). Retrying in ${delay + jitter}ms...`);
-      await sleep(delay + jitter);
-      delay *= 2;
-      continue;
-    }
-
-    if (error || isRetryable) {
-      syncError(`Failed in sxSlides for ${prop}.${method}`, error);
-      return { data: null, response: responseSyncify(response) };
-    }
-    return { data: response.data, response: responseSyncify(response) };
-  }
+  return sxRetry(Auth, tag, async () => {
+    return apiClient[prop][method](params, options);
+  });
 };

package/src/support/sxtoken.js

@@ -0,0 +1,15 @@
+import { Auth } from './auth.js'
+
+/**
+ * fetch effective user access token
+ */
+export const sxGetAccessToken = async () => {
+  return await Auth.getAccessToken()
+}
+
+export const sxGetAccessTokenInfo = async () => {
+  return await Auth.getAccessTokenInfo()
+}
+export const sxGetSourceAccessTokenInfo = async () => {
+  return await Auth.getSourceAccessTokenInfo()
+}

package/src/support/syncit.js

@@ -270,11 +270,14 @@ const fxInit = ({
   // this is the path of the runing main process
   const mainDir = path.dirname(process.argv[1]);
 
+  // Resolve defaults relative to mainDir if they are relative
+  const resolve = (p) => path.isAbsolute(p) ? p : path.resolve(mainDir, p);
+
   // because this is all run in a synced subprocess it's not an async result
   const synced = callSync("sxInit", {
-    claspPath,
-    settingsPath,
-    manifestPath,
+    claspPath: resolve(claspPath),
+    settingsPath: resolve(settingsPath),
+    manifestPath: resolve(manifestPath),
     mainDir,
     cachePath,
     propertiesPath,
@@ -283,22 +286,22 @@ const fxInit = ({
 
   const {
     scopes,
+    activeUser,
+    effectiveUser,
     projectId,
-    tokenInfo,
-    accessToken,
     settings,
     manifest,
     clasp,
   } = synced;
 
-  // set these values from the subprocess for the main project
+  // set these values from the subprocess into the main project version of auth
   Auth.setProjectId(projectId);
-  //Auth.setAuth(scopes)
-  Auth.setTokenInfo(tokenInfo);
-  //Auth.setAccessToken(accessToken)
   Auth.setSettings(settings);
   Auth.setClasp(clasp);
   Auth.setManifest(manifest);
+  Auth.setActiveUser(activeUser);
+  Auth.setEffectiveUser(effectiveUser);
+  Auth.setTokenScopes(scopes);
   return synced;
 };
 
@@ -367,6 +370,17 @@ const fxFetchAll = (requests, responseFields) => {
   return callSync("sxFetchAll", requests, responseFields);
 };
 
+const fxGetAccessToken = () => {
+  return callSync("sxGetAccessToken");
+};
+
+const fxGetAccessTokenInfo = () => {
+  return callSync("sxGetAccessTokenInfo");
+};
+const fxGetSourceAccessTokenInfo = () => {
+  return callSync("sxGetSourceAccessTokenInfo");
+};
+
 const fxSheets = (args) =>
   fxGeneric({
     ...args,
@@ -430,5 +444,8 @@ export const Syncit = {
   fxForms,
   fxGmail,
   fxCalendar,
-  fxDriveExport
+  fxDriveExport,
+  fxGetAccessToken,
+  fxGetAccessTokenInfo,
+  fxGetSourceAccessTokenInfo
 }

package/src/support/workersync/sxfunctions.js

@@ -10,5 +10,7 @@ export * from "../sxauth.js";
 export * from "../sxgmail.js";
 export * from "../sxcalendar.js";
 export * from "../sxxlsx.js";
+export * from "../sxtoken.js";
+
 
 

package/src/support/workersync/synclogger.js

@@ -1,18 +1,35 @@
 import fs from 'node:fs';
 import { isQuiet } from '../slogger.js';
+
+const isCloudRun = !!process.env.K_SERVICE;
+const getTimestamp = () => new Date().toISOString();
+
+const writeSyncLog = (stream, severity, message) => {
+  if (isCloudRun) {
+    const entry = {
+      severity: severity,
+      message: message,
+      timestamp: getTimestamp()
+    };
+    fs.writeSync(stream, JSON.stringify(entry) + '\n');
+  } else {
+    fs.writeSync(stream, `${getTimestamp()} ${message}\n`);
+  }
+};
+
 export const syncLog = (message) => {
-  if (!isQuiet) fs.writeSync(1, `[Worker] ${message}\n`);
+  if (!isQuiet) writeSyncLog(1, 'DEFAULT', `[Worker] ${message}`);
 };
 
 export const syncWarn = (message) => {
-  fs.writeSync(1, `[Worker Warn] ${message}\n`);
+  writeSyncLog(1, 'WARNING', `[Worker Warn] ${message}`);
 };
 
 export const syncInfo = (message) => {
-  if (!isQuiet) fs.writeSync(1, `[Worker Info] ${message}\n`);
+  if (!isQuiet) writeSyncLog(1, 'INFO', `[Worker Info] ${message}`);
 };
+
 export const syncError = (message, error) => {
-  // Providing the error object is optional
   const errorMessage = error ? `: ${error?.stack || error}` : '';
-  fs.writeSync(2, `[Worker Error] ${message}${errorMessage}\n`);
+  writeSyncLog(2, 'ERROR', `[Worker Error] ${message}${errorMessage}`);
 };