@mcpher/gas-fakes 2.3.4 → 2.3.6

package/README.md

@@ -196,6 +196,7 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [running gas-fakes on Amazon AWS lambda](https://github.com/brucemcpherson/gas-fakes-containers)
 - [running gas-fakes on Azure ACA](https://github.com/brucemcpherson/gas-fakes-containers)
 - [running gas-fakes on Github actions](https://github.com/brucemcpherson/gas-fakes-containers)
+- [jdbc notes](jdbc-notes.md)
 - [Yes – you can run native apps script code on Azure ACA as well!](https://ramblings.mcpher.com/yes-you-can-run-native-apps-script-code-on-azure-aca-as-well/)
 - [Yes – you can run native apps script code on AWS Lambda!](https://ramblings.mcpher.com/apps-script-on-aws-lambda/)
 - [initial idea and thoughts](https://ramblings.mcpher.com/a-proof-of-concept-implementation-of-apps-script-environment-on-node/)

package/appsscript.json

@@ -5,6 +5,7 @@
   "oauthScopes": [
     "https://www.googleapis.com/auth/cloud-platform",
     "https://www.googleapis.com/auth/drive",
+    "https://www.googleapis.com/auth/sqlservice",
     "https://www.googleapis.com/auth/script.external_request",
     "https://www.googleapis.com/auth/spreadsheets",
     "https://www.googleapis.com/auth/userinfo.email",

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

@@ -11,6 +11,7 @@
     "@sindresorhus/is": "^7.2.0",
     "acorn": "^8.16.0",
     "adm-zip": "^0.5.16",
+    "child_process": "^1.0.2",
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
     "fast-xml-parser": "^5.5.9",
@@ -22,6 +23,8 @@
     "keyv": "^5.6.0",
     "keyv-file": "^5.3.3",
     "mime": "^4.1.0",
+    "mysql2": "^3.20.0",
+    "pg": "^8.20.0",
     "prompts": "^2.4.2",
     "sleep-synchronously": "^2.0.0",
     "zod": "^4.3.6"
@@ -35,7 +38,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.3.4",
+  "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/skills-lock.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "skills": {
+    "neon-postgres": {
+      "source": "neondatabase/agent-skills",
+      "sourceType": "github",
+      "computedHash": "391693eee67001639ab65474df185da3ea5cf9ee4b99badecfd64561113edbb4"
+    }
+  }
+}

package/src/cli/app.js

@@ -175,6 +175,24 @@ export async function main() {
     .option("-t, --tools <string>", "Path to custom tools file.")
     .action(startMcpServer);
 
+  // --- JDBC Command ---
+  program
+    .command("jdbc")
+    .description("Parse a JDBC connection string and output configurations for App Script and Local environments.")
+    .requiredOption("-c, --connection-string <string>", "The JDBC connection string to parse.")
+    .action(async (options) => {
+      try {
+        const { newFakeJdbcService } = await import("../services/jdbc/fakejdbcservice.js");
+        const service = newFakeJdbcService();
+        const config = service.__normalConnection(options.connectionString);
+        process.stdout.write(JSON.stringify(config, null, 2) + "\n");
+        process.exit(0);
+      } catch (err) {
+        process.stderr.write(`Error parsing connection string: ${err.message}\n`);
+        process.exit(1);
+      }
+    });
+
   program.showHelpAfterError("(add --help for additional information)");
 
   await program.parseAsync(process.argv);

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 ---
 
@@ -242,16 +241,60 @@ export async function initializeConfiguration(options = {}) {
   // Discover Scopes from appsscript.json (Shared across backends)
   const manifestPath = path.resolve(process.cwd(), responses.GF_MANIFEST_PATH);
   let manifestScopes = [];
+  let manifestHasCloudSql = false;
   if (fs.existsSync(manifestPath)) {
     try {
       const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
       manifestScopes = manifest.oauthScopes || [];
       console.log(`...discovered ${manifestScopes.length} scopes in ${responses.GF_MANIFEST_PATH}`);
+      
+      // Check for JDBC or Cloud SQL usage (simplified check)
+      const manifestContent = fs.readFileSync(manifestPath, "utf8");
+      if (manifestContent.includes("jdbc:google:") || manifestContent.includes("Jdbc.")) {
+        manifestHasCloudSql = true;
+      }
     } catch (err) {
       console.warn(`...warning: failed to parse ${responses.GF_MANIFEST_PATH}.`);
     }
   }
 
+  // --- Step 2.5: Database & Cloud SQL Proxy Configuration ---
+  const hasJdbc = manifestHasCloudSql || Object.keys(existingConfig).some(k => k.includes("DATABASE_URL"));
+  if (hasJdbc) {
+    console.log("\n--- Configuring Database & Cloud SQL Auth Proxy ---");
+    
+    // Check if proxy is installed
+    let proxyInstalled = false;
+    try {
+      execSync("cloud-sql-proxy --version", { stdio: "ignore" });
+      proxyInstalled = true;
+    } catch (e) {
+      // not installed or not in path
+    }
+
+    if (!proxyInstalled) {
+      console.log("\x1b[1;33mNotice: Cloud SQL Auth Proxy is not installed or not in your PATH.\x1b[0m");
+      console.log("If you plan to test Google Cloud SQL locally, please install it:");
+      console.log("  - macOS (Homebrew): brew install google-cloud-sdk");
+      console.log("    then: gcloud components install cloud-sql-proxy");
+      console.log("  - Other: https://cloud.google.com/sql/docs/postgres/sql-proxy#install\n");
+    }
+
+    const dbQuestions = [
+      {
+        type: "toggle",
+        name: "GF_USE_CLOUD_PG_SQL_PROXY",
+        message: "Use Cloud SQL Auth Proxy for local database connections?",
+        initial: existingConfig.GF_USE_CLOUD_PG_SQL_PROXY === "true",
+        active: "yes",
+        inactive: "no"
+      }
+    ];
+
+    const dbResponses = await prompts(dbQuestions);
+    Object.assign(responses, dbResponses);
+  }
+
   // --- Step 3: Google Workspace Configuration ---
   if (platforms.includes("google")) {
     console.log("\n--- Configuring Google Workspace backend ---");
@@ -756,8 +799,8 @@ export async function authenticateUser(options = {}) {
         runCommandSync(`gcloud iam service-accounts add-iam-policy-binding "${sa_email}" --member="user:${current_user}" --role="roles/iam.serviceAccountTokenCreator" --quiet`, true);
 
         const saUniqueId = execSync(`gcloud iam service-accounts describe "${sa_email}" --format="value(uniqueId)"`, { shell: true }).toString().trim();
-        console.log(`\n\x1b[1;33m************************************************************************`);
-        console.log(`IMPORTANT: Add this to Admin Console (Domain-Wide Delegation):`);
+        console.log(`\n\x1b[1;33m*************************************************************************************************`);
+        console.log(`IMPORTANT: If you haven't already done it, add this to Admin Console (Domain-Wide Delegation):`);
         console.log(`************************************************************************\x1b[0m`);
         console.log(`URL: https://admin.google.com/ac/owl/domainwidedelegation`);
         console.log(`Client ID: ${saUniqueId}\nScopes: ${scopes}`);

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/index.js

@@ -28,3 +28,5 @@ import './services/slidesapp/app.js'
 import './services/mimetype/app.js'
 import './services/lock/app.js'
 import './services/libhandlerapp/app.js'
+import './services/jdbc/app.js'
+

package/src/services/jdbc/app.js

@@ -0,0 +1,9 @@
+/**
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
+ */
+import { newFakeJdbcService as maker } from './fakejdbcservice.js';
+import { lazyLoaderApp } from '../common/lazyloader.js'
+
+let _app = null;
+_app = lazyLoaderApp(_app, 'Jdbc', maker);

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

@@ -0,0 +1,66 @@
+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) {
+    this.__fakeObjectType = 'JdbcConnection';
+    this._url = url;
+    
+    // Connect synchronously using the worker
+    // Only pass arguments that are provided to avoid passing null/undefined to Syncit
+    const args = [url];
+    if (user !== null && typeof user !== 'undefined') args.push(user);
+    if (password !== null && typeof password !== 'undefined') args.push(password);
+    
+    const result = Syncit.fxJdbcConnect(...args);
+    this._connectionId = result.id;
+  }
+
+  // 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 newFakeJdbcDatabaseMetaData(this, this._connectionId, this._url);
+  }
+
+  // To match GAS JdbcConnection basic capabilities
+  close() {
+    if (this._connectionId) {
+      Syncit.fxJdbcClose(this._connectionId);
+      this._connectionId = null;
+    }
+  }
+
+  isClosed() {
+    return !this._connectionId;
+  }
+}
+
+export const newFakeJdbcConnection = (...args) => Proxies.guard(new FakeJdbcConnection(...args));