@mcpher/gas-fakes 2.3.5 → 2.3.6

package/main.js

@@ -1,8 +1,6 @@
 // testing locally
 // sync the version with gas fakes code since they share a package.json
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
-const pjson = require('./package.json');
-const VERSION = pjson.version;
-console.log (`...gas-fakes version ${VERSION}`)
+import { initMetadata } from './src/support/metadata.js';
+initMetadata();
+console.log (`...gas-fakes version ${globalThis.GasFakes.metadata.version}`)
 import './src/index.js'

package/package.json

@@ -38,7 +38,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.3.5",
+  "version": "2.3.6",
   "license": "MIT",
   "main": "main.js",
   "description": "An implementation of the Google Workspace Apps Script runtime: Run native App Script Code on Node and Cloud Run",

package/src/cli/setup.js

@@ -5,9 +5,8 @@ import path from "path";
 import os from "os";
 import { randomUUID } from "node:crypto";
 import { execSync } from "child_process";
-import { checkForGcloudCli, checkForAzCli, runCommandSync } from "./utils.js";
+import { checkForGcloudCli, runCommandSync } from "./utils.js";
 import { getMsGraphToken, mapGasScopesToMsGraph } from "../support/msgraph/msauth.js";
-import { Platforms, PlatformDefaults } from "../services/enums/platformenums.js";
 
 // --- Utility Functions ---
 

package/src/cli/utils.js

@@ -1,9 +1,8 @@
 import { spawn, execSync } from "child_process";
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-const pjson = require("../../package.json");
+import { initMetadata } from "../support/metadata.js";
+const GasFakes = initMetadata();
 
-export const VERSION = pjson.version;
+export const VERSION = GasFakes.metadata.version;
 export const CLI_VERSION = "0.0.20";
 export const MCP_VERSION = "0.0.7";
 

package/src/services/jdbc/fakejdbcarray.js

@@ -0,0 +1,37 @@
+import { Proxies } from '../../support/proxies.js';
+
+class FakeJdbcArray {
+  constructor(data, baseType, baseTypeName) {
+    this.__fakeObjectType = 'JdbcArray';
+    this._data = Array.isArray(data) ? data : [data];
+    this._baseType = baseType || 12; // VARCHAR
+    this._baseTypeName = baseTypeName || 'VARCHAR';
+    this._isClosed = false;
+  }
+
+  getArray() {
+    if (this._isClosed) throw new Error('Array is closed.');
+    return this._data;
+  }
+
+  getBaseType() {
+    return this._baseType;
+  }
+
+  getBaseTypeName() {
+    return this._baseTypeName;
+  }
+
+  getResultSet() {
+    // In actual JDBC this returns a result set with columns INDEX and VALUE
+    // For now, returning null as it's rarely used in Apps Script JDBC context
+    return null;
+  }
+
+  free() {
+    this._isClosed = true;
+    this._data = null;
+  }
+}
+
+export const newFakeJdbcArray = (...args) => Proxies.guard(new FakeJdbcArray(...args));

package/src/services/jdbc/fakejdbcbigdecimal.js

@@ -0,0 +1,63 @@
+/**
+ * Fake implementation of Google Apps Script Jdbc's BigDecimal (java.math.BigDecimal proxy)
+ */
+export class FakeJdbcBigDecimal {
+  constructor(val) {
+    this.val = String(val);
+  }
+
+  /**
+   * Returns the string representation of this BigDecimal.
+   * This is how it's typically used in Apps Script for comparison or output.
+   */
+  toString() {
+    return this.val;
+  }
+
+  /**
+   * Returns the value as a JavaScript number.
+   * Corresponds to Java's doubleValue()
+   */
+  doubleValue() {
+    return Number(this.val);
+  }
+
+  /**
+   * Returns the value as an integer.
+   * Corresponds to Java's intValue()
+   */
+  intValue() {
+    return Math.floor(Number(this.val));
+  }
+
+  /**
+   * Returns the value as a long integer.
+   * Corresponds to Java's longValue()
+   */
+  longValue() {
+    return Math.floor(Number(this.val));
+  }
+
+  /**
+   * Returns the string representation without scientific notation.
+   * Corresponds to Java's toPlainString()
+   */
+  toPlainString() {
+    return this.val;
+  }
+
+  /**
+   * Returns the scale of this BigDecimal.
+   */
+  scale() {
+    const parts = this.val.split('.');
+    return parts.length > 1 ? parts[1].length : 0;
+  }
+
+  /**
+   * Returns the precision of this BigDecimal.
+   */
+  precision() {
+    return this.val.replace('.', '').replace('-', '').length;
+  }
+}

package/src/services/jdbc/fakejdbcblob.js

@@ -0,0 +1,67 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeInputStream } from '../../support/fakeinputstream.js';
+
+class FakeJdbcBlob {
+  constructor(data) {
+    this.__fakeObjectType = 'JdbcBlob';
+    // Ensure we have a Buffer/Uint8Array
+    this._data = (data instanceof Uint8Array || Buffer.isBuffer(data)) 
+      ? data 
+      : Buffer.from(data || '');
+    this._isClosed = false;
+  }
+
+  getBinaryStream() {
+    if (this._isClosed) throw new Error('Blob is closed.');
+    return newFakeInputStream(this._data);
+  }
+
+  getBytes(pos, len) {
+    if (this._isClosed) throw new Error('Blob is closed.');
+    // pos is 1-indexed in JDBC
+    const start = pos - 1;
+    const end = start + len;
+    return Array.from(this._data.slice(start, end));
+  }
+
+  length() {
+    if (this._isClosed) throw new Error('Blob is closed.');
+    return this._data.length;
+  }
+
+  position(pattern, start) {
+    if (this._isClosed) throw new Error('Blob is closed.');
+    // Simple implementation for parity
+    const patternBuffer = (pattern instanceof FakeJdbcBlob) ? pattern._data : Buffer.from(pattern);
+    const index = this._data.indexOf(patternBuffer, start - 1);
+    return index === -1 ? -1 : index + 1;
+  }
+
+  setBinaryStream(pos) {
+    // Not fully supported in fake, but allows setting direction
+    return this.getBinaryStream();
+  }
+
+  setBytes(pos, bytes) {
+    if (this._isClosed) throw new Error('Blob is closed.');
+    const start = pos - 1;
+    const newBytes = Buffer.from(bytes);
+    const newData = Buffer.alloc(Math.max(this._data.length, start + newBytes.length));
+    this._data.copy(newData);
+    newBytes.copy(newData, start);
+    this._data = newData;
+    return newBytes.length;
+  }
+
+  truncate(len) {
+    if (this._isClosed) throw new Error('Blob is closed.');
+    this._data = this._data.slice(0, len);
+  }
+
+  free() {
+    this._isClosed = true;
+    this._data = null;
+  }
+}
+
+export const newFakeJdbcBlob = (...args) => Proxies.guard(new FakeJdbcBlob(...args));

package/src/services/jdbc/fakejdbcclob.js

@@ -0,0 +1,67 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeInputStream, newFakeReader } from '../../support/fakeinputstream.js';
+
+class FakeJdbcClob {
+  constructor(data) {
+    this.__fakeObjectType = 'JdbcClob';
+    this._data = String(data || '');
+    this._isClosed = false;
+  }
+
+  getAsciiStream() {
+    if (this._isClosed) throw new Error('Clob is closed.');
+    return newFakeInputStream(Buffer.from(this._data, 'ascii'));
+  }
+
+  getCharacterStream() {
+    if (this._isClosed) throw new Error('Clob is closed.');
+    return newFakeReader(this._data);
+  }
+
+  getSubString(pos, len) {
+    if (this._isClosed) throw new Error('Clob is closed.');
+    // pos is 1-indexed
+    return this._data.substring(pos - 1, pos - 1 + len);
+  }
+
+  length() {
+    if (this._isClosed) throw new Error('Clob is closed.');
+    return this._data.length;
+  }
+
+  position(pattern, start) {
+    if (this._isClosed) throw new Error('Clob is closed.');
+    const searchPattern = (pattern instanceof FakeJdbcClob) ? pattern._data : String(pattern);
+    const index = this._data.indexOf(searchPattern, start - 1);
+    return index === -1 ? -1 : index + 1;
+  }
+
+  setAsciiStream(pos) {
+    return this.getAsciiStream();
+  }
+
+  setCharacterStream(pos) {
+    return this.getCharacterStream();
+  }
+
+  setString(pos, str) {
+    if (this._isClosed) throw new Error('Clob is closed.');
+    const start = pos - 1;
+    const prefix = this._data.substring(0, start).padEnd(start, ' ');
+    const suffix = this._data.substring(start + str.length);
+    this._data = prefix + str + suffix;
+    return str.length;
+  }
+
+  truncate(len) {
+    if (this._isClosed) throw new Error('Clob is closed.');
+    this._data = this._data.substring(0, len);
+  }
+
+  free() {
+    this._isClosed = true;
+    this._data = null;
+  }
+}
+
+export const newFakeJdbcClob = (...args) => Proxies.guard(new FakeJdbcClob(...args));

package/src/services/jdbc/fakejdbcconnection.js

@@ -1,6 +1,8 @@
 import { Proxies } from '../../support/proxies.js';
 import { Syncit } from '../../support/syncit.js';
 import { newFakeJdbcStatement } from './fakejdbcstatement.js';
+import { newFakeJdbcPreparedStatement } from './fakejdbcpreparedstatement.js';
+import { newFakeJdbcDatabaseMetaData } from './fakejdbcdatabasemetadata.js';
 
 class FakeJdbcConnection {
   constructor(url, user, password) {
@@ -17,16 +19,35 @@ class FakeJdbcConnection {
     this._connectionId = result.id;
   }
 
-  createStatement() {
-    return newFakeJdbcStatement(this._connectionId);
+  // GAS overload: createStatement() or createStatement(resultSetType, resultSetConcurrency)
+  // resultSetType/Concurrency parameters are advisory in the fake since results are buffered in memory.
+  createStatement(resultSetType, resultSetConcurrency) {
+    return newFakeJdbcStatement(this, this._connectionId);
+  }
+
+  prepareStatement(sql) {
+    return newFakeJdbcPreparedStatement(this, this._connectionId, sql);
+  }
+
+  commit() {
+    Syncit.fxJdbcCommit(this._connectionId);
+  }
+
+  rollback() {
+    Syncit.fxJdbcRollback(this._connectionId);
+  }
+
+  setAutoCommit(autoCommit) {
+    Syncit.fxJdbcSetAutoCommit(this._connectionId, autoCommit);
+  }
+
+  getAutoCommit() {
+    // We don't currently track this in the proxy, but GAS default is true
+    return true; 
   }
 
   getMetaData() {
-    // Return an object that mimics DatabaseMetaData
-    return Proxies.guard({
-      __fakeObjectType: 'JdbcDatabaseMetaData',
-      getURL: () => this._url
-    });
+    return newFakeJdbcDatabaseMetaData(this, this._connectionId, this._url);
   }
 
   // To match GAS JdbcConnection basic capabilities