js4j 0.1.0

package/src/gateway.js

@@ -0,0 +1,222 @@
+'use strict';
+
+const { ConnectionPool, GatewayConnection } = require('./connection');
+const { JVMView } = require('./jvmView');
+const { createJavaObject, gatewayMethods } = require('./javaObject');
+const { CallbackServer, ProxyPool } = require('./callbackServer');
+const {
+  SHUTDOWN_GATEWAY_COMMAND_NAME,
+  ENTRY_POINT_OBJECT_ID,
+  END,
+  END_COMMAND_PART,
+  decodeReturnValue,
+  ARRAY_COMMAND_NAME,
+  ARRAY_CREATE_SUB_COMMAND_NAME,
+  JVMVIEW_COMMAND_NAME,
+  JVMVIEW_IMPORT_SUB_COMMAND_NAME,
+  encodeCommandPart,
+  STRING_TYPE,
+} = require('./protocol');
+const { Js4JError, Js4JNetworkError } = require('./exceptions');
+
+// ---------------------------------------------------------------------------
+// GatewayParameters — mirrors py4j's GatewayParameters
+// ---------------------------------------------------------------------------
+
+class GatewayParameters {
+  constructor(options = {}) {
+    this.host = options.host || '127.0.0.1';
+    this.port = options.port || 25333;
+    this.authToken = options.authToken || null;
+    this.autoField = options.autoField || false;
+    this.autoConvert = options.autoConvert || false;
+    this.enableMemoryManagement = options.enableMemoryManagement || false;
+    this.poolSize = options.poolSize || 4;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// CallbackServerParameters — mirrors py4j's CallbackServerParameters
+// ---------------------------------------------------------------------------
+
+class CallbackServerParameters {
+  constructor(options = {}) {
+    this.host = options.host || '127.0.0.1';
+    this.port = options.port || 25334;
+    this.daemonize = options.daemonize !== undefined ? options.daemonize : true;
+    this.propagateException = options.propagateException || false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// GatewayClient — internal client that actually talks to the GatewayServer
+// ---------------------------------------------------------------------------
+
+class GatewayClient {
+  constructor(gatewayParameters, proxyPool) {
+    this._params = gatewayParameters;
+    this._proxyPool = proxyPool || new ProxyPool();
+    this._pool = new ConnectionPool(
+      {
+        host: gatewayParameters.host,
+        port: gatewayParameters.port,
+        authToken: gatewayParameters.authToken,
+      },
+      gatewayParameters.poolSize
+    );
+  }
+
+  async _sendCommand(command) {
+    return this._pool.withConnection((conn) => conn.sendCommand(command));
+  }
+
+  async shutdownGateway() {
+    const cmd = SHUTDOWN_GATEWAY_COMMAND_NAME + END + END_COMMAND_PART;
+    try {
+      await this._sendCommand(cmd);
+    } catch (_) {}
+  }
+
+  closeAll() {
+    this._pool.closeAll();
+  }
+}
+
+Object.assign(GatewayClient.prototype, gatewayMethods);
+
+// ---------------------------------------------------------------------------
+// JavaGateway — main entry point (mirrors py4j's JavaGateway)
+// ---------------------------------------------------------------------------
+
+class JavaGateway {
+  constructor(gatewayParameters, callbackServerParameters) {
+    this._gatewayParams =
+      gatewayParameters instanceof GatewayParameters
+        ? gatewayParameters
+        : new GatewayParameters(gatewayParameters || {});
+
+    this._callbackParams =
+      callbackServerParameters instanceof CallbackServerParameters
+        ? callbackServerParameters
+        : new CallbackServerParameters(callbackServerParameters || {});
+
+    this._proxyPool = new ProxyPool();
+    this._client = new GatewayClient(this._gatewayParams, this._proxyPool);
+    this._callbackServer = null;
+    this._connected = false;
+
+    this.jvm = null;
+    this.entry_point = null;
+  }
+
+  async connect() {
+    await this._client._pool.withConnection(async () => {});
+    this._connected = true;
+    this.jvm = new JVMView(this._client);
+    this.entry_point = createJavaObject(ENTRY_POINT_OBJECT_ID, this._client);
+    return this;
+  }
+
+  async startCallbackServer() {
+    if (this._callbackServer && this._callbackServer.listening) {
+      return this._callbackServer;
+    }
+    this._callbackServer = new CallbackServer({
+      host: this._callbackParams.host,
+      port: this._callbackParams.port,
+      proxyPool: this._proxyPool,
+      gatewayClient: this._client,
+    });
+    await this._callbackServer.start();
+    return this._callbackServer;
+  }
+
+  async shutdownCallbackServer() {
+    if (this._callbackServer) {
+      await this._callbackServer.stop();
+      this._callbackServer = null;
+    }
+  }
+
+  async close() {
+    await this.shutdownCallbackServer();
+    this._client.closeAll();
+    this._connected = false;
+  }
+
+  async shutdown() {
+    try { await this._client.shutdownGateway(); } catch (_) {}
+    await this.close();
+  }
+
+  async getField(javaObject, fieldName) {
+    return this._client.getField(javaObject, fieldName);
+  }
+
+  async setField(javaObject, fieldName, value) {
+    return this._client.setField(javaObject, fieldName, value);
+  }
+
+  async newArray(javaClass, ...dimensions) {
+    if (dimensions.length === 0) {
+      throw new Js4JError('newArray requires at least one dimension');
+    }
+    const classFqn = (javaClass && (javaClass._fqn || javaClass._targetId)) || String(javaClass);
+    let command =
+      ARRAY_COMMAND_NAME +
+      ARRAY_CREATE_SUB_COMMAND_NAME +
+      STRING_TYPE + classFqn + END_COMMAND_PART;
+    for (const dim of dimensions) {
+      command += encodeCommandPart(dim, this._proxyPool);
+    }
+    command += END + END_COMMAND_PART;
+    const answer = await this._client._sendCommand(command);
+    return decodeReturnValue(answer, this._client);
+  }
+
+  async newJvmView(name = 'custom jvm') {
+    const command =
+      JVMVIEW_COMMAND_NAME +
+      JVMVIEW_IMPORT_SUB_COMMAND_NAME +
+      name + END_COMMAND_PART +
+      END + END_COMMAND_PART;
+    await this._client._sendCommand(command);
+    return new (require('./jvmView').JVMView)(this._client);
+  }
+
+  async getMethods(javaObject) { return this._client.getMethods(javaObject); }
+  async getFields(javaObject) { return this._client.getFields(javaObject); }
+
+  async isInstanceOf(javaObject, javaClass) {
+    const classFqn =
+      typeof javaClass === 'string' ? javaClass : javaClass._fqn || javaClass._targetId;
+    return this._client.callMethod(javaObject._targetId, 'getClass().isAssignableFrom', [classFqn]);
+  }
+
+  async javaImport(classFqn) { return this.jvm.javaImport(classFqn); }
+
+  async help(target) {
+    if (typeof target === 'string') return this.jvm.help(target);
+    return this._client.help(target);
+  }
+
+  async releaseObject(javaObject) {
+    const targetId = typeof javaObject === 'string' ? javaObject : javaObject._targetId;
+    return this._client.releaseObject(targetId);
+  }
+
+  async detach(javaObject) { return this.releaseObject(javaObject); }
+
+  async getStaticMembers(javaClass) { return this._client.getStaticMembers(javaClass); }
+
+  get connected() { return this._connected; }
+  get gatewayParameters() { return this._gatewayParams; }
+  get callbackServerParameters() { return this._callbackParams; }
+}
+
+module.exports = {
+  JavaGateway,
+  GatewayParameters,
+  CallbackServerParameters,
+  GatewayClient,
+};

package/src/javaObject.js

@@ -0,0 +1,267 @@
+'use strict';
+
+const {
+  CALL_COMMAND_NAME,
+  CONSTRUCTOR_COMMAND_NAME,
+  FIELD_COMMAND_NAME,
+  FIELD_GET_SUB_COMMAND_NAME,
+  FIELD_SET_SUB_COMMAND_NAME,
+  MEMORY_COMMAND_NAME,
+  MEMORY_DEL_SUB_COMMAND_NAME,
+  DIR_COMMAND_NAME,
+  DIR_FIELDS_SUBCOMMAND_NAME,
+  DIR_METHODS_SUBCOMMAND_NAME,
+  DIR_STATIC_SUBCOMMAND_NAME,
+  HELP_COMMAND_NAME,
+  HELP_OBJECT_SUBCOMMAND_NAME,
+  REFLECTION_COMMAND_NAME,
+  REFL_GET_MEMBER_SUB_COMMAND_NAME,
+  STATIC_PREFIX,
+  END,
+  END_COMMAND_PART,
+  encodeCommandPart,
+  decodeReturnValue,
+} = require('./protocol');
+
+// Symbols used to expose internal state without polluting method namespace
+const TARGET_ID = Symbol('targetId');
+const CLIENT = Symbol('client');
+const CLASS_FQN = Symbol('classFqn');
+
+/**
+ * Build the argument section of a command string from a JS args array.
+ */
+function buildArgsCommand(args, proxyPool) {
+  let s = '';
+  for (const arg of args) {
+    s += encodeCommandPart(arg, proxyPool);
+  }
+  return s;
+}
+
+/**
+ * Wrap a raw Java object ID returned by the gateway into a typed wrapper.
+ * The GatewayClient calls this internally via _wrapObject().
+ */
+function wrapJavaObject(targetId, typeHint, gatewayClient) {
+  const {
+    LIST_TYPE,
+    SET_TYPE,
+    MAP_TYPE,
+    ARRAY_TYPE,
+    ITERATOR_TYPE,
+  } = require('./protocol');
+
+  const {
+    createJavaList,
+    createJavaSet,
+    createJavaMap,
+    createJavaArray,
+    createJavaIterator,
+  } = require('./collections');
+
+  switch (typeHint) {
+    case LIST_TYPE:
+      return createJavaList(targetId, gatewayClient);
+    case SET_TYPE:
+      return createJavaSet(targetId, gatewayClient);
+    case MAP_TYPE:
+      return createJavaMap(targetId, gatewayClient);
+    case ARRAY_TYPE:
+      return createJavaArray(targetId, gatewayClient);
+    case ITERATOR_TYPE:
+      return createJavaIterator(targetId, gatewayClient);
+    default:
+      return createJavaObject(targetId, gatewayClient);
+  }
+}
+
+/**
+ * Create a Proxy that wraps a Java object reference.
+ *
+ * Property access returns an async method caller:
+ *   const result = await javaObj.someMethod(arg1, arg2);
+ *
+ * Mirrors py4j's JavaObject class.
+ */
+function createJavaObject(targetId, gatewayClient) {
+  const internal = {
+    [TARGET_ID]: targetId,
+    [CLIENT]: gatewayClient,
+    _targetId: targetId,
+    _gatewayClient: gatewayClient,
+  };
+
+  const handler = {
+    get(target, prop, receiver) {
+      if (typeof prop === 'symbol') return target[prop];
+      if (Object.prototype.hasOwnProperty.call(target, prop)) return target[prop];
+      if (prop === 'then') return undefined;
+      return (...args) => gatewayClient.callMethod(targetId, prop, args);
+    },
+
+    set(target, prop, value) {
+      if (prop in target) {
+        target[prop] = value;
+        return true;
+      }
+      throw new Error(
+        `Cannot set Java field '${prop}' with assignment. Use gateway.setField(obj, '${prop}', value) instead.`
+      );
+    },
+
+    has(target, prop) {
+      if (prop in target) return true;
+      return false;
+    },
+  };
+
+  return new Proxy(internal, handler);
+}
+
+/**
+ * Low-level gateway client methods used by JavaObject, JavaClass, etc.
+ * These are mixed into the GatewayClient prototype in gateway.js.
+ */
+const gatewayMethods = {
+  async callMethod(targetId, methodName, args) {
+    const argsStr = buildArgsCommand(args, this._proxyPool);
+    const command =
+      CALL_COMMAND_NAME +
+      targetId + END_COMMAND_PART +
+      methodName + END_COMMAND_PART +
+      argsStr +
+      END + END_COMMAND_PART;
+    const answer = await this._sendCommand(command);
+    return decodeReturnValue(answer, this);
+  },
+
+  async callConstructor(classFqn, args) {
+    const argsStr = buildArgsCommand(args, this._proxyPool);
+    const command =
+      CONSTRUCTOR_COMMAND_NAME +
+      classFqn + END_COMMAND_PART +
+      argsStr +
+      END + END_COMMAND_PART;
+    const answer = await this._sendCommand(command);
+    return decodeReturnValue(answer, this);
+  },
+
+  async getField(targetOrId, fieldName) {
+    const targetId = typeof targetOrId === 'string' ? targetOrId : targetOrId._targetId;
+
+    // Static fields on classes: targetId has the "z:" prefix (STATIC_PREFIX).
+    // The FIELD_GET command only handles registered object instances, not class FQNs.
+    // Use the REFLECTION GET_MEMBER command instead — this is what py4j Python does.
+    if (targetId.startsWith(STATIC_PREFIX)) {
+      const fqn = targetId.slice(STATIC_PREFIX.length);
+      const command =
+        REFLECTION_COMMAND_NAME +
+        REFL_GET_MEMBER_SUB_COMMAND_NAME +
+        fqn + END_COMMAND_PART +
+        fieldName + END_COMMAND_PART +
+        END + END_COMMAND_PART;
+      const answer = await this._sendCommand(command);
+      return decodeReturnValue(answer, this);
+    }
+
+    const command =
+      FIELD_COMMAND_NAME +
+      FIELD_GET_SUB_COMMAND_NAME +
+      targetId + END_COMMAND_PART +
+      fieldName + END_COMMAND_PART +
+      END + END_COMMAND_PART;
+    const answer = await this._sendCommand(command);
+    return decodeReturnValue(answer, this);
+  },
+
+  async setField(targetOrId, fieldName, value) {
+    const targetId = typeof targetOrId === 'string' ? targetOrId : targetOrId._targetId;
+    const command =
+      FIELD_COMMAND_NAME +
+      FIELD_SET_SUB_COMMAND_NAME +
+      targetId + END_COMMAND_PART +
+      fieldName + END_COMMAND_PART +
+      encodeCommandPart(value, this._proxyPool) +
+      END + END_COMMAND_PART;
+    const answer = await this._sendCommand(command);
+    return decodeReturnValue(answer, this);
+  },
+
+  async releaseObject(targetId) {
+    const command =
+      MEMORY_COMMAND_NAME +
+      MEMORY_DEL_SUB_COMMAND_NAME +
+      targetId + END_COMMAND_PART +
+      END + END_COMMAND_PART;
+    try {
+      await this._sendCommand(command);
+    } catch (_) {}
+  },
+
+  async getMethods(targetOrId) {
+    const targetId = typeof targetOrId === 'string' ? targetOrId : targetOrId._targetId;
+    const command =
+      DIR_COMMAND_NAME +
+      DIR_METHODS_SUBCOMMAND_NAME +
+      targetId + END_COMMAND_PART +
+      END + END_COMMAND_PART;
+    const answer = await this._sendCommand(command);
+    const decoded = decodeReturnValue(answer, this);
+    if (typeof decoded === 'string') return decoded.split('\n').filter(Boolean);
+    return decoded;
+  },
+
+  async getFields(targetOrId) {
+    const targetId = typeof targetOrId === 'string' ? targetOrId : targetOrId._targetId;
+    const command =
+      DIR_COMMAND_NAME +
+      DIR_FIELDS_SUBCOMMAND_NAME +
+      targetId + END_COMMAND_PART +
+      END + END_COMMAND_PART;
+    const answer = await this._sendCommand(command);
+    const decoded = decodeReturnValue(answer, this);
+    if (typeof decoded === 'string') return decoded.split('\n').filter(Boolean);
+    return decoded;
+  },
+
+  async getStaticMembers(classOrId) {
+    const targetId = typeof classOrId === 'string' ? classOrId : (classOrId._fqn || classOrId._targetId);
+    const command =
+      DIR_COMMAND_NAME +
+      DIR_STATIC_SUBCOMMAND_NAME +
+      targetId + END_COMMAND_PART +
+      END + END_COMMAND_PART;
+    const answer = await this._sendCommand(command);
+    const decoded = decodeReturnValue(answer, this);
+    if (typeof decoded === 'string') return decoded.split('\n').filter(Boolean);
+    return decoded;
+  },
+
+  async help(targetOrId, pattern) {
+    const targetId = typeof targetOrId === 'string' ? targetOrId : targetOrId._targetId;
+    let command =
+      HELP_COMMAND_NAME +
+      HELP_OBJECT_SUBCOMMAND_NAME +
+      targetId + END_COMMAND_PART;
+    if (pattern) {
+      command += pattern + END_COMMAND_PART;
+    }
+    command += END + END_COMMAND_PART;
+    const answer = await this._sendCommand(command);
+    return decodeReturnValue(answer, this);
+  },
+
+  _wrapObject(targetId, typeHint) {
+    return wrapJavaObject(targetId, typeHint, this);
+  },
+
+  _lookupProxy(proxyId) {
+    if (this._proxyPool) {
+      return this._proxyPool.get(proxyId);
+    }
+    return null;
+  },
+};
+
+module.exports = { createJavaObject, wrapJavaObject, gatewayMethods, buildArgsCommand, TARGET_ID, CLIENT };

package/src/jvmView.js

@@ -0,0 +1,224 @@
+'use strict';
+
+const {
+  JVMVIEW_COMMAND_NAME,
+  JVMVIEW_CLASS_SUB_COMMAND_NAME,
+  JVMVIEW_IMPORT_SUB_COMMAND_NAME,
+  JVMVIEW_REMOVE_IMPORT_SUB_COMMAND_NAME,
+  HELP_COMMAND_NAME,
+  HELP_CLASS_SUBCOMMAND_NAME,
+  END,
+  END_COMMAND_PART,
+  STATIC_PREFIX,
+  DEFAULT_JVM_ID,
+  decodeReturnValue,
+  encodeCommandPart,
+} = require('./protocol');
+
+/**
+ * Create a JavaClass proxy for a fully-qualified class name.
+ *
+ * The returned object behaves as:
+ *   - A callable that invokes the Java constructor when awaited:
+ *       const sb = await gateway.jvm.java.lang.StringBuilder('hello');
+ *   - A source of static method accessors:
+ *       const val = await gateway.jvm.java.lang.System.currentTimeMillis();
+ *   - A source of static field accessors via gateway.getField(JavaClass, 'FIELD')
+ *
+ * Mirrors py4j's JavaClass.
+ */
+function createJavaClass(fqn, gatewayClient) {
+  // Use a function as the Proxy target so the proxy is callable
+  const base = function JavaClass() {};
+  base._fqn = fqn;
+  // py4j uses a "z:" prefix for static method/field calls so Java knows to
+  // dispatch statically rather than looking up a registered object instance.
+  base._targetId = STATIC_PREFIX + fqn;
+  base._gatewayClient = gatewayClient;
+  base._isJavaClass = true;
+
+  const handler = {
+    // Property access → static method/field accessor
+    get(target, prop) {
+      if (typeof prop === 'symbol') return target[prop];
+      // Only pass through OWN properties (e.g. _fqn, _targetId, _isJavaClass).
+      // Inherited Function prototype methods (valueOf, toString, call, apply, …)
+      // must NOT shadow Java static members with the same name.
+      if (Object.prototype.hasOwnProperty.call(target, prop)) return target[prop];
+      if (prop === 'then') return undefined; // not a Promise
+
+      // Return an async function that calls a static method.
+      // Java's CallCommand recognises the "z:" prefix and dispatches
+      // the call statically on the named class.
+      return (...args) => gatewayClient.callMethod(STATIC_PREFIX + fqn, prop, args);
+    },
+
+    // Called when the JavaClass proxy itself is invoked as a function → constructor
+    apply(target, thisArg, args) {
+      return gatewayClient.callConstructor(fqn, args);
+    },
+
+    // Support `new JavaClass(...)` as well
+    construct(target, args) {
+      return gatewayClient.callConstructor(fqn, args);
+    },
+  };
+
+  return new Proxy(base, handler);
+}
+
+/**
+ * Create a JavaPackage proxy for a partial FQN (e.g. "java", "java.lang").
+ *
+ * Attribute traversal accumulates the package path until it looks like a
+ * class name (starts with an uppercase letter) or the value is used
+ * as a constructor/method target, at which point a JavaClass is returned.
+ *
+ * Mirrors py4j's JavaPackage.
+ */
+function createJavaPackage(fqn, gatewayClient) {
+  const base = function JavaPackage() {
+    throw new Error(
+      `'${fqn}' looks like a package, not a class. ` +
+      `Traverse to a class first, e.g. gateway.jvm.java.lang.String`
+    );
+  };
+  base._fqn = fqn;
+  base._isJavaPackage = true;
+
+  const handler = {
+    get(target, prop) {
+      if (typeof prop === 'symbol') return target[prop];
+      if (prop in target) return target[prop];
+      if (prop === 'then') return undefined; // not a Promise
+
+      const childFqn = fqn ? `${fqn}.${prop}` : prop;
+
+      // Heuristic: uppercase first char → probably a class
+      if (prop[0] === prop[0].toUpperCase() && prop[0] !== prop[0].toLowerCase()) {
+        return createJavaClass(childFqn, gatewayClient);
+      }
+      // Otherwise, keep building the package chain
+      return createJavaPackage(childFqn, gatewayClient);
+    },
+
+    apply() {
+      throw new Error(`'${fqn}' is a Java package, not a class.`);
+    },
+  };
+
+  return new Proxy(base, handler);
+}
+
+/**
+ * JVMView — the root of the jvm.* namespace.
+ *
+ * Mirrors py4j's JVMView.  Provides:
+ *   gateway.jvm.java.lang.String(...)          → constructor
+ *   gateway.jvm.java.lang.System.out           → static field (via getField)
+ *   gateway.jvm.java.util.ArrayList            → JavaClass
+ *   await gateway.jvmImport('java.util.*')     → shortcut imports (client-side)
+ */
+class JVMView {
+  constructor(gatewayClient, id) {
+    this._gatewayClient = gatewayClient;
+    this._imports = new Map(); // shortName → fqn
+    // JVM view ID used in JVMVIEW protocol commands. Default is "rj" (py4j DEFAULT_JVM_ID).
+    this._id = id || DEFAULT_JVM_ID;
+
+    // Return a Proxy over this instance so that `jvm.java` works
+    return new Proxy(this, {
+      get(target, prop) {
+        if (typeof prop === 'symbol') return target[prop];
+        if (prop in target) return target[prop];
+        if (prop === 'then') return undefined;
+
+        // Check shortcut imports first
+        if (target._imports.has(prop)) {
+          const fqn = target._imports.get(prop);
+          return createJavaClass(fqn, target._gatewayClient);
+        }
+
+        // Start building a package/class chain
+        if (prop[0] === prop[0].toUpperCase() && prop[0] !== prop[0].toLowerCase()) {
+          return createJavaClass(prop, target._gatewayClient);
+        }
+        return createJavaPackage(prop, target._gatewayClient);
+      },
+    });
+  }
+
+  /**
+   * Import a Java class or package into the JVM namespace, creating a shortcut.
+   * Mirrors py4j's `java_import(gateway.jvm, 'java.util.ArrayList')`.
+   * @param {string} fqn - Fully-qualified class name (wildcards supported for packages)
+   * @returns {Promise<void>}
+   */
+  async javaImport(fqn) {
+    const command =
+      JVMVIEW_COMMAND_NAME +
+      JVMVIEW_IMPORT_SUB_COMMAND_NAME +
+      this._id + END_COMMAND_PART +
+      fqn + END_COMMAND_PART +
+      END + END_COMMAND_PART;
+    const answer = await this._gatewayClient._sendCommand(command);
+    const result = decodeReturnValue(answer, this._gatewayClient);
+
+    // Register the simple name as a shortcut
+    const parts = fqn.split('.');
+    const simpleName = parts[parts.length - 1];
+    if (simpleName !== '*') {
+      this._imports.set(simpleName, fqn);
+    }
+    return result;
+  }
+
+  /**
+   * Remove a previously imported class from this JVMView's shortcut namespace.
+   * Mirrors py4j's remove_imports().
+   * @param {string} fqn - Fully-qualified class name to remove
+   * @returns {Promise<void>}
+   */
+  async removeImport(fqn) {
+    const command =
+      JVMVIEW_COMMAND_NAME +
+      JVMVIEW_REMOVE_IMPORT_SUB_COMMAND_NAME +
+      this._id + END_COMMAND_PART +
+      fqn + END_COMMAND_PART +
+      END + END_COMMAND_PART;
+    await this._gatewayClient._sendCommand(command);
+
+    // Remove from local shortcut map
+    const parts = fqn.split('.');
+    const simpleName = parts[parts.length - 1];
+    if (simpleName !== '*') {
+      this._imports.delete(simpleName);
+    }
+  }
+
+  /**
+   * Look up a class by FQN in the gateway's JVM.
+   * @param {string} classFqn
+   * @returns {JavaClass}
+   */
+  getClass(classFqn) {
+    return createJavaClass(classFqn, this._gatewayClient);
+  }
+
+  /**
+   * Get help string for a Java class.
+   * @param {string} classFqn
+   * @returns {Promise<string>}
+   */
+  async help(classFqn) {
+    const command =
+      HELP_COMMAND_NAME +
+      HELP_CLASS_SUBCOMMAND_NAME +
+      classFqn + END_COMMAND_PART +
+      END + END_COMMAND_PART;
+    const answer = await this._gatewayClient._sendCommand(command);
+    return decodeReturnValue(answer, this._gatewayClient);
+  }
+}
+
+module.exports = { JVMView, createJavaClass, createJavaPackage };