@mcpher/gas-fakes 2.3.5 → 2.3.7

package/src/services/jdbc/fakejdbcresultset.js

@@ -1,13 +1,24 @@
 import { Proxies } from '../../support/proxies.js';
 import { newFakeJdbcResultSetMetaData } from './fakejdbcresultsetmetadata.js';
+import { FakeJdbcBigDecimal } from './fakejdbcbigdecimal.js';
+import { newFakeJdbcBlob } from './fakejdbcblob.js';
+import { newFakeJdbcClob } from './fakejdbcclob.js';
+import { newFakeJdbcArray } from './fakejdbcarray.js';
+import { newFakeInputStream, newFakeReader } from '../../support/fakeinputstream.js';
 
 class FakeJdbcResultSet {
-  constructor(result) {
+  constructor(result, statement) {
     this.__fakeObjectType = 'JdbcResultSet';
     this._rows = result.rows || [];
     this._fields = result.fields || [];
     this._currentIndex = -1;
     this._isClosed = false;
+    this._statement = statement;
+    this._lastValue = null;
+    this._fetchSize = 0;
+    this._fetchDirection = 1000; // FETCH_FORWARD
+    this._type = 1003; // TYPE_FORWARD_ONLY
+    this._concurrency = 1007; // CONCUR_READ_ONLY
   }
 
   next() {
@@ -16,15 +27,96 @@ class FakeJdbcResultSet {
     return this._currentIndex < this._rows.length;
   }
 
-  _getValue(columnIndex) {
+  _getValue(columnIdentifier) {
     if (this._isClosed) throw new Error('ResultSet is closed.');
     if (this._currentIndex < 0 || this._currentIndex >= this._rows.length) {
       throw new Error('No current row.');
     }
+    
+    let index;
+    if (typeof columnIdentifier === 'number') {
+      index = columnIdentifier;
+    } else {
+      index = this.findColumn(columnIdentifier);
+    }
+    
     // JDBC columns are 1-indexed
-    const field = this._fields[columnIndex - 1];
-    if (!field) throw new Error(`Invalid column index: ${columnIndex}`);
-    return this._rows[this._currentIndex][field.name];
+    const field = this._fields[index - 1];
+    if (!field) throw new Error(`Invalid column identifier: ${columnIdentifier}`);
+    const val = this._rows[this._currentIndex][field.name];
+    this._lastValue = val;
+    return val;
+  }
+
+  wasNull() {
+    return this._lastValue === null || this._lastValue === undefined;
+  }
+
+  absolute(row) {
+    if (this._isClosed) throw new Error('ResultSet is closed.');
+    if (row === 0) throw new Error('Rows are 1-indexed.');
+    if (row > 0) {
+      this._currentIndex = row - 1;
+    } else {
+      this._currentIndex = this._rows.length + row;
+    }
+    return this._currentIndex >= 0 && this._currentIndex < this._rows.length;
+  }
+
+  afterLast() {
+    if (this._isClosed) throw new Error('ResultSet is closed.');
+    this._currentIndex = this._rows.length;
+  }
+
+  beforeFirst() {
+    if (this._isClosed) throw new Error('ResultSet is closed.');
+    this._currentIndex = -1;
+  }
+
+  first() {
+    return this.absolute(1);
+  }
+
+  last() {
+    return this.absolute(-1);
+  }
+
+  previous() {
+    if (this._isClosed) throw new Error('ResultSet is closed.');
+    if (this._currentIndex > -1) {
+      this._currentIndex--;
+    }
+    return this._currentIndex >= 0 && this._currentIndex < this._rows.length;
+  }
+
+  relative(rows) {
+    return this.absolute(this._currentIndex + 1 + rows);
+  }
+
+  isAfterLast() {
+    if (this._isClosed) throw new Error('ResultSet is closed.');
+    return this._currentIndex >= this._rows.length && this._rows.length > 0;
+  }
+
+  isBeforeFirst() {
+    if (this._isClosed) throw new Error('ResultSet is closed.');
+    return this._currentIndex < 0 && this._rows.length > 0;
+  }
+
+  isFirst() {
+    if (this._isClosed) throw new Error('ResultSet is closed.');
+    return this._currentIndex === 0 && this._rows.length > 0;
+  }
+
+  isLast() {
+    if (this._isClosed) throw new Error('ResultSet is closed.');
+    return this._currentIndex === this._rows.length - 1 && this._rows.length > 0;
+  }
+
+  getRow() {
+    if (this._isClosed) throw new Error('ResultSet is closed.');
+    if (this._currentIndex < 0 || this._currentIndex >= this._rows.length) return 0;
+    return this._currentIndex + 1;
   }
 
   getString(columnIndex) {
@@ -37,20 +129,102 @@ class FakeJdbcResultSet {
     return val !== null && val !== undefined ? parseInt(val, 10) : 0;
   }
 
+  getLong(columnIndex) {
+    return this.getInt(columnIndex);
+  }
+
+  getShort(columnIndex) {
+    return this.getInt(columnIndex);
+  }
+
+  getBoolean(columnIndex) {
+    const val = this._getValue(columnIndex);
+    return Boolean(val);
+  }
+
   getFloat(columnIndex) {
+    const val = this._getValue(columnIndex);
+    // GAS getFloat() returns IEEE 754 single-precision (32-bit float)
+    return val !== null && val !== undefined ? Math.fround(parseFloat(val)) : 0.0;
+  }
+
+  getDouble(columnIndex) {
+    // getDouble() returns full 64-bit precision
     const val = this._getValue(columnIndex);
     return val !== null && val !== undefined ? parseFloat(val) : 0.0;
   }
+
+  getBigDecimal(columnIndex) {
+    const val = this._getValue(columnIndex);
+    return val !== null && val !== undefined ? new FakeJdbcBigDecimal(val) : null;
+  }
   
   getDate(columnIndex) {
     const val = this._getValue(columnIndex);
     return val ? new Date(val) : null;
   }
 
+  getTimestamp(columnIndex) {
+    return this.getDate(columnIndex);
+  }
+
   getObject(columnIndex) {
     return this._getValue(columnIndex);
   }
 
+  getBytes(columnIndex) {
+    const val = this._getValue(columnIndex);
+    if (val === null || val === undefined) return null;
+    return Array.from(Buffer.from(val));
+  }
+
+  getBlob(columnIndex) {
+    const val = this._getValue(columnIndex);
+    return val !== null && val !== undefined ? newFakeJdbcBlob(val) : null;
+  }
+
+  getClob(columnIndex) {
+    const val = this._getValue(columnIndex);
+    return val !== null && val !== undefined ? newFakeJdbcClob(val) : null;
+  }
+
+  getArray(columnIndex) {
+    const val = this._getValue(columnIndex);
+    return val !== null && val !== undefined ? newFakeJdbcArray(val) : null;
+  }
+
+  getUnicodeStream(columnIndex) {
+    const val = this._getValue(columnIndex);
+    return val !== null && val !== undefined ? newFakeInputStream(Buffer.from(String(val), 'utf8')) : null;
+  }
+
+  getAsciiStream(columnIndex) {
+    const val = this._getValue(columnIndex);
+    return val !== null && val !== undefined ? newFakeInputStream(Buffer.from(String(val), 'ascii')) : null;
+  }
+
+  getBinaryStream(columnIndex) {
+    const val = this._getValue(columnIndex);
+    return val !== null && val !== undefined ? newFakeInputStream(Buffer.from(val)) : null;
+  }
+
+  getCharacterStream(columnIndex) {
+    const val = this._getValue(columnIndex);
+    return val !== null && val !== undefined ? newFakeReader(String(val)) : null;
+  }
+
+  getCursorName() {
+    if (this._isClosed) throw new Error('ResultSet is closed.');
+    return 'fake-cursor';
+  }
+
+  findColumn(columnLabel) {
+    if (this._isClosed) throw new Error('ResultSet is closed.');
+    const index = this._fields.findIndex(f => f.name.toLowerCase() === columnLabel.toLowerCase());
+    if (index === -1) throw new Error(`Column not found: ${columnLabel}`);
+    return index + 1;
+  }
+
   getMetaData() {
     if (this._isClosed) throw new Error('ResultSet is closed.');
     return newFakeJdbcResultSetMetaData(this._fields);
@@ -62,6 +236,54 @@ class FakeJdbcResultSet {
     this._fields = [];
   }
 
+  getByte(columnIndex) {
+    return this.getInt(columnIndex);
+  }
+
+  getTime(columnIndex) {
+    return this.getDate(columnIndex);
+  }
+
+  getURL(columnIndex) {
+    return this.getString(columnIndex);
+  }
+
+  getFetchDirection() {
+    return this._fetchDirection;
+  }
+
+  getFetchSize() {
+    return this._fetchSize;
+  }
+
+  getType() {
+    return this._type;
+  }
+
+  getConcurrency() {
+    return this._concurrency;
+  }
+
+  setFetchDirection(direction) {
+    this._fetchDirection = direction;
+  }
+
+  setFetchSize(rows) {
+    this._fetchSize = rows;
+  }
+
+  getStatement() {
+    return this._statement;
+  }
+
+  getWarnings() {
+    return null;
+  }
+
+  clearWarnings() {
+    // No-op for fake
+  }
+
   isClosed() {
     return this._isClosed;
   }

package/src/services/jdbc/fakejdbcresultsetmetadata.js

@@ -34,6 +34,14 @@ class FakeJdbcResultSetMetaData {
     if (!field) throw new Error(`Invalid column index: ${column}`);
     return `TYPE_${field.dataTypeID}`; // basic fallback
   }
+
+  getTableName(column) {
+    return "";
+  }
+
+  getSchemaName(column) {
+    return "";
+  }
 }
 
 export const newFakeJdbcResultSetMetaData = (...args) => Proxies.guard(new FakeJdbcResultSetMetaData(...args));

package/src/services/jdbc/fakejdbcservice.js

@@ -7,12 +7,12 @@ class FakeJdbcService {
     this.__fakeObjectType = 'Jdbc';
   }
 
-  /**
+    /**
    * Connects to a JDBC database.
    * In gas-fakes, we primarily support postgres via pg module, mapping jdbc:postgresql to it.
    * 
    * @param {string} url The URL of the database to connect to.
-   * @param {string} user (optional) The user name to connect as.
+   * @param {string|object} user (optional) The user name to connect as, or an object of property/value pairs.
    * @param {string} password (optional) The password for the user.
    * @returns {JdbcConnection} A JDBC connection object.
    */
@@ -24,39 +24,49 @@ class FakeJdbcService {
     }
 
     // Explicitly merge user/password into the URL structure for gas-fakes processing
-    if (user !== undefined && user !== null && password !== undefined && password !== null) {
-      try {
-        const cleanUrl = finalUrl.replace(/^jdbc:google:/, '').replace(/^jdbc:/, '');
-        const urlObj = new URL(cleanUrl);
-        urlObj.username = encodeURIComponent(String(user));
-        urlObj.password = encodeURIComponent(String(password));
-        
-        // Restore the prefix
-        let prefix = "jdbc:";
-        if (finalUrl.startsWith("jdbc:google:")) prefix = "jdbc:google:";
-        finalUrl = prefix + urlObj.toString();
-      } catch (e) {
-        // Fallback for malformed URLs
+    if (typeof user === 'object' && user !== null) {
+      // Handling info object
+      const info = user;
+      const u = info.user || info.userName;
+      const p = info.password;
+      if (u && p) {
+        finalUrl = this._mergeCredentials(finalUrl, u, p);
       }
+      // Note: other info properties aren't currently merged into the URL string,
+      // but Syncit.fxJdbcConnect will receive the info object anyway.
+    } else if (user !== undefined && user !== null && password !== undefined && password !== null) {
+      finalUrl = this._mergeCredentials(finalUrl, user, password);
     }
     
-    // We intentionally pass undefined for user and password so the worker only sees finalUrl
-    return newFakeJdbcConnection(finalUrl, undefined, undefined);
+    // Pass user (which might be the info object) and password to the connection
+    return newFakeJdbcConnection(finalUrl, user, password);
+  }
+
+  _mergeCredentials(url, user, password) {
+    try {
+      const cleanUrl = url.replace(/^jdbc:google:/, '').replace(/^jdbc:/, '');
+      const urlObj = new URL(cleanUrl);
+      urlObj.username = encodeURIComponent(String(user));
+      urlObj.password = encodeURIComponent(String(password));
+      
+      // Restore the prefix
+      let prefix = "jdbc:";
+      if (url.startsWith("jdbc:google:")) prefix = "jdbc:google:";
+      return prefix + urlObj.toString();
+    } catch (e) {
+      return url; // Fallback for malformed URLs
+    }
   }
 
   /**
-   * Connects to a Google Cloud SQL instance - but on gas-fakes its the same thing
+   * Connects to a Google Cloud SQL instance.
    * @param {string} url The URL of the database to connect to.
-   * @param {string} user (optional) The user name to connect as.
+   * @param {string|object} user (optional) The user name to connect as, or an object of property/value pairs.
    * @param {string} password (optional) The password for the user.
    * @returns {JdbcConnection} A JDBC connection object.
    */
   getCloudSqlConnection(url, user, password) {
-    return this.getConnection (url, user, password)
-  }
-
-  parseCsv(csv) {
-    throw new Error('Not implemented: parseCsv');
+    return this.getConnection(url, user, password);
   }
 
   __useProxy  (val) {
@@ -90,7 +100,7 @@ class FakeJdbcService {
 
     const cleanUrl = url.replace(/^jdbc:google:/, "").replace(/^jdbc:/, "");
 
-    let scheme, user, pass, host, db;
+    let scheme, user, pass, host, db, searchString = "";
 
     try {
       const parsed = new URL(cleanUrl);
@@ -110,7 +120,7 @@ class FakeJdbcService {
       remainingParams.delete('user');
       remainingParams.delete('password');
       
-      const searchString = remainingParams.toString();
+      searchString = remainingParams.toString();
       if (searchString) {
         db = `${db}?${searchString}`;
       }
@@ -181,7 +191,7 @@ class FakeJdbcService {
     // Live Apps Script Java JDBC requires properly encoded URI components to prevent "Connection URL is malformed"
     const gasAuthQuery = (encodedUser || encodedPass) ? `?user=${encodedUser}&password=${encodedPass}` : '';
     
-    // --- GAS ---
+    // --- GAS --- (Rule 3: Strip ALL SSL/Tunneling parameters)
     let gasUrl, gasConnectionString, gasFullConnectionString;
     let isCloudSqlConnection = false;
 
@@ -192,8 +202,8 @@ class FakeJdbcService {
       isCloudSqlConnection = true;
     } else {
       gasUrl = `${protocol}${remoteHost}/${pureDb}`;
-      gasConnectionString = `${protocol}${remoteHost}/${pureDb}`;
-      // Drop all original query parameters, only append explicit unencoded user, password, and ssl
+      gasConnectionString = gasUrl;
+      // Single-argument getConnection is discouraged on GAS, but if used, only append credentials
       gasFullConnectionString = `${protocol}${remoteHost}/${pureDb}${gasAuthQuery}`;
     }
 

package/src/services/jdbc/fakejdbcstatement.js

@@ -3,10 +3,39 @@ import { Syncit } from '../../support/syncit.js';
 import { newFakeJdbcResultSet } from './fakejdbcresultset.js';
 
 class FakeJdbcStatement {
-  constructor(connectionId) {
+  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) {
@@ -14,21 +43,138 @@ class FakeJdbcStatement {
     
     // Fetch result synchronously from worker
     const result = Syncit.fxJdbcQuery(this._connectionId, sql);
-    
-    return newFakeJdbcResultSet(result);
+    this._lastUpdateCount = -1;
+    this._lastResultSet = newFakeJdbcResultSet(result, this);
+    return this._lastResultSet;
   }
 
-  execute(sql) {
+  execute(sql, autoGeneratedKeysOrIndexesOrNames) {
     if (this._isClosed) throw new Error('Statement is closed.');
     
-    // In actual JDBC, execute returns true if the first result is a ResultSet
-    // node-postgres gives us an array of rows or a rowCount.
     const result = Syncit.fxJdbcQuery(this._connectionId, sql);
-    return result.fields && result.fields.length > 0;
+    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() {

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;
+}