@mcpher/gas-fakes 2.3.4 → 2.3.6

package/src/services/jdbc/fakejdbcstatement.js

@@ -0,0 +1,185 @@
+import { Proxies } from '../../support/proxies.js';
+import { Syncit } from '../../support/syncit.js';
+import { newFakeJdbcResultSet } from './fakejdbcresultset.js';
+
+class FakeJdbcStatement {
+  constructor(connection, connectionId) {
+    this.__fakeObjectType = 'JdbcStatement';
+    this._connection = connection;
+    this._connectionId = connectionId;
+    this._isClosed = false;
+    this._batch = [];
+    this._fetchSize = 0;
+    this._maxRows = 0;
+    this._queryTimeout = 0;
+    this._maxFieldSize = 0;
+    this._fetchDirection = 1000; // FETCH_FORWARD
+    this._isPoolable = false;
+    this._lastUpdateCount = -1;
+  }
+
+  addBatch(sql) {
+    if (this._isClosed) throw new Error('Statement is closed.');
+    this._batch.push(sql);
+  }
+
+  executeBatch() {
+    if (this._isClosed) throw new Error('Statement is closed.');
+    const results = [];
+    for (const sql of this._batch) {
+      const result = Syncit.fxJdbcQuery(this._connectionId, sql);
+      results.push(result.rowCount || 0);
+    }
+    this.clearBatch();
+    return results;
+  }
+
+  clearBatch() {
+    this._batch = [];
+  }
+
+  executeQuery(sql) {
+    if (this._isClosed) throw new Error('Statement is closed.');
+    
+    // Fetch result synchronously from worker
+    const result = Syncit.fxJdbcQuery(this._connectionId, sql);
+    this._lastUpdateCount = -1;
+    this._lastResultSet = newFakeJdbcResultSet(result, this);
+    return this._lastResultSet;
+  }
+
+  execute(sql, autoGeneratedKeysOrIndexesOrNames) {
+    if (this._isClosed) throw new Error('Statement is closed.');
+    
+    const result = Syncit.fxJdbcQuery(this._connectionId, sql);
+    this._lastUpdateCount = result.rowCount || 0;
+    if (result.fields && result.fields.length > 0) {
+      this._lastResultSet = newFakeJdbcResultSet(result, this);
+      return true;
+    } else {
+      this._lastResultSet = null;
+      return false;
+    }
+  }
+
+  executeUpdate(sql, autoGeneratedKeysOrIndexesOrNames) {
+    if (this._isClosed) throw new Error('Statement is closed.');
+    const result = Syncit.fxJdbcQuery(this._connectionId, sql);
+    this._lastUpdateCount = result.rowCount;
+    this._lastResultSet = null;
+    return result.rowCount;
+  }
+
+  cancel() {
+    // Stub: No-op for fake
+  }
+
+  clearWarnings() {
+    // Stub: No-op for fake
+  }
+
+  getConnection() {
+    return this._connection;
+  }
+
+  getFetchDirection() {
+    return this._fetchDirection;
+  }
+
+  getFetchSize() {
+    return this._fetchSize;
+  }
+
+  getGeneratedKeys() {
+    // Return empty results as we don't currently track generated auto-increment IDs
+    return newFakeJdbcResultSet({ fields: [], rows: [] }, this);
+  }
+
+  getMaxFieldSize() {
+    return this._maxFieldSize;
+  }
+
+  getMaxRows() {
+    return this._maxRows;
+  }
+
+  getMoreResults(current) {
+    // We only support one result set at a time per statement in this fake
+    return false;
+  }
+
+  getQueryTimeout() {
+    return this._queryTimeout;
+  }
+
+  getResultSetConcurrency() {
+    return 1007; // CONCUR_READ_ONLY
+  }
+
+  getResultSetHoldability() {
+    return 1; // HOLD_CURSORS_OVER_COMMIT
+  }
+
+  getResultSetType() {
+    return 1003; // TYPE_FORWARD_ONLY
+  }
+
+  getWarnings() {
+    return null;
+  }
+
+  isPoolable() {
+    return this._isPoolable;
+  }
+
+  setCursorName(name) {
+    // Stub: No-op for fake
+  }
+
+  setEscapeProcessing(enable) {
+    // Stub: No-op for fake
+  }
+
+  setFetchDirection(direction) {
+    this._fetchDirection = direction;
+  }
+
+  setFetchSize(rows) {
+    this._fetchSize = rows;
+  }
+
+  setMaxFieldSize(max) {
+    this._maxFieldSize = max;
+  }
+
+  setMaxRows(max) {
+    this._maxRows = max;
+  }
+
+  setPoolable(poolable) {
+    this._isPoolable = poolable;
+  }
+
+  setQueryTimeout(seconds) {
+    this._queryTimeout = seconds;
+  }
+
+  getUpdateCount() {
+    return this._lastUpdateCount || 0;
+  }
+
+  getResultSet() {
+    return this._lastResultSet;
+  }
+
+  close() {
+    this._isClosed = true;
+    this._lastResultSet = null;
+  }
+
+  isClosed() {
+    return this._isClosed;
+  }
+}
+
+export const newFakeJdbcStatement = (...args) => Proxies.guard(new FakeJdbcStatement(...args));

package/src/support/fakeinputstream.js

@@ -0,0 +1,42 @@
+import { Proxies } from './proxies.js';
+
+class FakeInputStream {
+  constructor(data) {
+    this.__fakeObjectType = 'InputStream';
+    this._data = data instanceof Uint8Array ? data : Buffer.from(data || '');
+    this._pos = 0;
+  }
+
+  read() {
+    if (this._pos >= this._data.length) return -1;
+    return this._data[this._pos++];
+  }
+
+  available() {
+    return this._data.length - this._pos;
+  }
+
+  close() {
+    this._pos = this._data.length;
+  }
+}
+
+class FakeReader {
+  constructor(data) {
+    this.__fakeObjectType = 'Reader';
+    this._data = String(data || '');
+    this._pos = 0;
+  }
+
+  read() {
+    if (this._pos >= this._data.length) return -1;
+    return this._data.charCodeAt(this._pos++);
+  }
+
+  close() {
+    this._pos = this._data.length;
+  }
+}
+
+export const newFakeInputStream = (...args) => Proxies.guard(new FakeInputStream(...args));
+export const newFakeReader = (...args) => Proxies.guard(new FakeReader(...args));

package/src/support/metadata.js

@@ -0,0 +1,16 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+/**
+ * Initializes the global GasFakes metadata object.
+ * @param {string} packageJsonPath The relative path to package.json from this file.
+ * @returns {object} The GasFakes global object.
+ */
+export function initMetadata(packageJsonPath = '../../package.json') {
+  // add the version number to gasfakes metadata
+  if (!globalThis.GasFakes) globalThis.GasFakes = {};
+  const pjson = require(packageJsonPath);
+  if (!globalThis.GasFakes.metadata) globalThis.GasFakes.metadata =  {}
+  globalThis.GasFakes.metadata.version = pjson.version
+  return globalThis.GasFakes;
+}

package/src/support/sxauth.js

@@ -128,6 +128,32 @@ export const sxInit = async ({ manifestPath, claspPath, settingsPath, cachePath,
 
     } catch (err) {
       syncWarn(`Google authentication failed: ${err.message}`);
+
+      // Provide guidance for Domain Wide Delegation issues
+      if (err.message.includes('unauthorized_client')) {
+        const clientId = Auth.getClientId();
+        const msg = [
+          "",
+          "=".repeat(80),
+          "GOOGLE AUTHENTICATION ERROR: unauthorized_client",
+          "This usually means Domain-Wide Delegation (DWD) is missing for one or more scopes.",
+          "",
+          `Your Service Account Client ID is: ${clientId || 'unknown (check your service account JSON file)'}`,
+          "",
+          "The following scopes should be authorized in the Google Admin Console:",
+          finalScopes.join(","),
+          "",
+          "To fix this:",
+          "1. Go to https://admin.google.com",
+          "2. Security -> Access and data control -> API controls",
+          "3. Manage Domain Wide Delegation",
+          "4. Find/Add your Client ID and ensure the list of scopes above matches exactly.",
+          "=".repeat(80),
+          ""
+        ].join("\n");
+        console.error(msg);
+      }
+
       if (!platforms.includes('ksuite') && !platforms.includes('msgraph')) throw err;
     }
   }

package/src/support/sxjdbc.js

@@ -0,0 +1,234 @@
+import pg from 'pg';
+import mysql from 'mysql2/promise';
+
+const connections = new Map();
+
+/**
+ * Creates and stores a connection to the database.
+ * @param {import('./auth.js').Auth} Auth
+ * @param {object} params
+ * @param {string} params.url JDBC connection URL
+ * @param {string} params.user Optional username
+ * @param {string} params.password Optional password
+ * @returns {object} Connection details/ID
+ */
+export const sxJdbcConnect = async (Auth, { url, user, password }) => {
+  let connectionString = url;
+  let type = 'pg';
+
+  if (url.startsWith('jdbc:postgresql:')) {
+    connectionString = url.replace('jdbc:postgresql:', 'postgresql:');
+    type = 'pg';
+  } else if (url.startsWith('jdbc:mysql:')) {
+    connectionString = url.replace('jdbc:mysql:', 'mysql:');
+    type = 'mysql';
+  } else if (url.startsWith('jdbc:google:mysql:')) {
+    connectionString = url.replace('jdbc:google:mysql:', 'mysql:');
+    type = 'mysql';
+  } else if (url.startsWith('mysql:')) {
+    type = 'mysql';
+  }
+
+  // Parse custom flags
+  const disableSsl = connectionString.includes('ssl=false') || connectionString.includes('127.0.0.1');
+
+  let client;
+  const id = `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+  if (type === 'pg') {
+    // Strip ssl parameters to avoid conflict with explicit ssl object
+    let pgConnectionString = connectionString.replace(/([?&])ssl=[^&]*(&|$)/g, '$1').replace(/[?&]$/, '');
+
+    // Neon postgres usually requires ssl
+    if (pgConnectionString.includes('sslmode=require') && !pgConnectionString.includes('uselibpqcompat')) {
+      const separator = pgConnectionString.includes('?') ? '&' : '?';
+      pgConnectionString += `${separator}uselibpqcompat=true`;
+    }
+
+    const clientConfig = {
+      connectionString: pgConnectionString,
+      ssl: disableSsl ? false : { rejectUnauthorized: false }
+    };
+
+    if (user !== null && typeof user !== 'undefined' && password !== null && typeof password !== 'undefined') {
+      client = new pg.Client({
+        ...clientConfig,
+        user: String(user),
+        password: String(password)
+      });
+    } else {
+      client = new pg.Client(clientConfig);
+    }
+    await client.connect();
+  } else if (type === 'mysql') {
+    let cleanUrl = connectionString.replace(/^jdbc:/, '');
+    if (!cleanUrl.startsWith('mysql://')) {
+      cleanUrl = 'mysql://' + cleanUrl;
+    }
+    
+    let host = '127.0.0.1';
+    let port = 3306;
+    let database = '';
+    let urlUser;
+    let urlPassword;
+    
+    try {
+      const parsedUrl = new URL(cleanUrl);
+      host = parsedUrl.hostname;
+      port = parsedUrl.port ? parseInt(parsedUrl.port, 10) : 3306;
+      database = parsedUrl.pathname.replace(/^\//, '');
+      urlUser = parsedUrl.username ? decodeURIComponent(parsedUrl.username) : parsedUrl.searchParams.get('user');
+      urlPassword = parsedUrl.password ? decodeURIComponent(parsedUrl.password) : parsedUrl.searchParams.get('password');
+    } catch (e) {
+      // Fallback for weird formats (like Cloud SQL instance names without resolved IPs)
+      const match = cleanUrl.match(/^mysql:\/\/(?:([^:]+):([^@]+)@)?([^/]+?)(?::(\d+))?(?:\/([^?]+))?(?:\?(.*))?$/);
+      if (match) {
+        urlUser = match[1] ? decodeURIComponent(match[1]) : undefined;
+        urlPassword = match[2] ? decodeURIComponent(match[2]) : undefined;
+        host = match[3];
+        port = match[4] ? parseInt(match[4], 10) : 3306;
+        database = match[5] || '';
+      } else {
+        host = cleanUrl.replace(/^mysql:\/\//, '');
+      }
+    }
+
+    const finalUser = (user !== null && typeof user !== 'undefined') ? String(user) : urlUser;
+    const finalPassword = (password !== null && typeof password !== 'undefined') ? String(password) : urlPassword;
+
+    const mysqlConfig = {
+      host: host,
+      port: port,
+      database: database,
+      user: finalUser,
+      password: finalPassword,
+      ssl: disableSsl ? undefined : { rejectUnauthorized: false }
+    };
+
+    client = await mysql.createConnection(mysqlConfig);
+  }
+
+  connections.set(id, { client, type });
+  return { id };
+};
+
+/**
+ * Executes a query on a given connection.
+ * @param {import('./auth.js').Auth} Auth
+ * @param {object} params
+ * @param {string} params.connectionId The stored connection ID
+ * @param {string} params.sql The SQL query to execute
+ * @returns {object} The query result (rows, fields, etc.)
+ */
+export const sxJdbcQuery = async (Auth, { connectionId, sql }) => {
+  const entry = connections.get(connectionId);
+  if (!entry) throw new Error('Invalid or closed JDBC connection.');
+  
+  const { client, type } = entry;
+  
+  if (type === 'pg') {
+    const result = await client.query(sql);
+    const rows = Array.isArray(result) ? result[result.length - 1].rows : result.rows;
+    const fields = Array.isArray(result) ? result[result.length - 1].fields : result.fields;
+    const rowCount = Array.isArray(result) ? result[result.length - 1].rowCount : result.rowCount;
+    
+    return {
+      rows: rows || [],
+      fields: fields || [],
+      rowCount: rowCount || 0,
+    };
+  } else if (type === 'mysql') {
+    // mysql2 returns [rows, fields]
+    const [rows, fields] = await client.query(sql);
+    return {
+      rows: rows || [],
+      fields: fields || [], // mysql2 fields are objects with name, columnType, etc.
+      rowCount: (rows && rows.insertId) ? 1 : (rows && rows.affectedRows) || (rows && rows.length) || 0,
+    };
+  }
+};
+
+/**
+ * Executes a prepared statement on a given connection.
+ * @param {import('./auth.js').Auth} Auth
+ * @param {object} params
+ * @param {string} params.connectionId The stored connection ID
+ * @param {string} params.sql The SQL query with placeholders
+ * @param {any[]} params.values The parameter values
+ * @returns {object} The query result
+ */
+export const sxJdbcExecutePrepared = async (Auth, { connectionId, sql, values }) => {
+  const entry = connections.get(connectionId);
+  if (!entry) throw new Error('Invalid or closed JDBC connection.');
+  
+  const { client, type } = entry;
+  
+  if (type === 'pg') {
+    // pg uses $1, $2, etc. so we must convert ? to $n
+    let index = 1;
+    const pgSql = sql.replace(/\?/g, () => `$${index++}`);
+    const result = await client.query(pgSql, values);
+    return {
+      rows: result.rows || [],
+      fields: result.fields || [],
+      rowCount: result.rowCount || 0,
+    };
+  } else if (type === 'mysql') {
+    // mysql2 natively supports ? placeholders
+    const [rows, fields] = await client.execute(sql, values);
+    return {
+      rows: rows || [],
+      fields: fields || [],
+      rowCount: (rows && (rows.affectedRows || rows.length)) || 0,
+    };
+  }
+};
+
+export const sxJdbcCommit = async (Auth, { connectionId }) => {
+  return sxJdbcQuery(Auth, { connectionId, sql: 'COMMIT' });
+};
+
+export const sxJdbcRollback = async (Auth, { connectionId }) => {
+  return sxJdbcQuery(Auth, { connectionId, sql: 'ROLLBACK' });
+};
+
+/**
+ * Sets auto-commit mode for the connection.
+ * Note: Node drivers are technically always in a state where BEGIN is needed for transactions.
+ * @param {import('./auth.js').Auth} Auth
+ * @param {object} params
+ * @param {string} params.connectionId The stored connection ID
+ * @param {boolean} params.autoCommit Whether to enable auto-commit
+ */
+export const sxJdbcSetAutoCommit = async (Auth, { connectionId, autoCommit }) => {
+  const entry = connections.get(connectionId);
+  if (!entry) throw new Error('Invalid or closed JDBC connection.');
+  
+  if (!autoCommit) {
+    // If turning off auto-commit, start a transaction
+    await sxJdbcQuery(Auth, { connectionId, sql: 'BEGIN' });
+  }
+  entry.autoCommit = autoCommit;
+  return true;
+};
+
+/**
+ * Closes a given connection.
+ * @param {import('./auth.js').Auth} Auth
+ * @param {object} params
+ * @param {string} params.connectionId The stored connection ID
+ * @returns {boolean} True if closed successfully
+ */
+export const sxJdbcClose = async (Auth, { connectionId }) => {
+  const entry = connections.get(connectionId);
+  if (entry) {
+    const { client, type } = entry;
+    if (type === 'pg') {
+      await client.end();
+    } else if (type === 'mysql') {
+      await client.end();
+    }
+    connections.delete(connectionId);
+  }
+  return true;
+};

package/src/support/syncit.js

@@ -412,6 +412,45 @@ const fxTestRetry = (errorMessage) => {
   return safeCallSync("sxTestRetry", { errorMessage });
 };
 
+const fxJdbcConnect = (url, user, password) => {
+  const args = { url };
+  if (typeof user === 'object' && user !== null) {
+    // Handling info object
+    args.user = user.user || user.userName;
+    args.password = user.password;
+    // We could pass the whole object if the worker was ready for it, 
+    // but for now let's just stick to user/pass.
+  } else {
+    if (user !== null && typeof user !== 'undefined') args.user = user;
+    if (password !== null && typeof password !== 'undefined') args.password = password;
+  }
+  return safeCallSync("sxJdbcConnect", args);
+};
+
+const fxJdbcQuery = (connectionId, sql) => {
+  return safeCallSync("sxJdbcQuery", { connectionId, sql });
+};
+
+const fxJdbcExecutePrepared = (connectionId, sql, values) => {
+  return safeCallSync("sxJdbcExecutePrepared", { connectionId, sql, values });
+};
+
+const fxJdbcCommit = (connectionId) => {
+  return safeCallSync("sxJdbcCommit", { connectionId });
+};
+
+const fxJdbcRollback = (connectionId) => {
+  return safeCallSync("sxJdbcRollback", { connectionId });
+};
+
+const fxJdbcSetAutoCommit = (connectionId, autoCommit) => {
+  return safeCallSync("sxJdbcSetAutoCommit", { connectionId, autoCommit });
+};
+
+const fxJdbcClose = (connectionId) => {
+  return safeCallSync("sxJdbcClose", { connectionId });
+};
+
 const fxSheets = (args) =>
   fxGeneric({
     ...args,
@@ -479,5 +518,12 @@ export const Syncit = {
   fxGetAccessToken,
   fxGetAccessTokenInfo,
   fxGetSourceAccessTokenInfo,
-  fxTestRetry
+  fxTestRetry,
+  fxJdbcConnect,
+  fxJdbcQuery,
+  fxJdbcExecutePrepared,
+  fxJdbcCommit,
+  fxJdbcRollback,
+  fxJdbcSetAutoCommit,
+  fxJdbcClose
 }

package/src/support/workersync/sxfunctions.js

@@ -14,3 +14,4 @@ export * from "../sxtoken.js";
 
 
 
+export * from "../sxjdbc.js";