scoundrel-remote-eval 1.0.8 → 1.0.10

package/spec/support/jasmine.json

@@ -1,13 +0,0 @@
-{
-  "spec_dir": "spec",
-  "spec_files": [
-    "**/*[sS]pec.?(m)js"
-  ],
-  "helpers": [
-    "helpers/**/*.?(m)js"
-  ],
-  "env": {
-    "stopSpecOnExpectationFailure": false,
-    "random": true
-  }
-}

package/spec/web-socket-javascript-spec.js

@@ -1,66 +0,0 @@
-// @ts-check
-
-import Client from "../src/client/index.js"
-import ClientWebSocket from "../src/client/connections/web-socket/index.js"
-import Server from "../src/server/index.js"
-import ServerWebSocket from "../src/server/connections/web-socket/index.js"
-import {WebSocket, WebSocketServer} from "ws"
-
-const shared = {}
-
-describe("scoundrel - web-socket - javascript", () => {
-  beforeEach(async () => {
-    shared.wss = new WebSocketServer({port: 8080})
-    shared.serverWebSocket = new ServerWebSocket(shared.wss)
-    shared.server = new Server(shared.serverWebSocket)
-
-    shared.ws = new WebSocket("http://localhost:8080")
-    shared.clientWebSocket = new ClientWebSocket(shared.ws)
-
-    await shared.clientWebSocket.waitForOpened()
-
-    shared.client = new Client(shared.clientWebSocket)
-  })
-
-  afterEach(async () => {
-    await shared.client.close()
-    await shared.server.close()
-  })
-
-  it("creates a server and connects to it with the client", async () => {
-    const stringObject = await shared.client.newObjectWithReference("Array")
-
-    await stringObject.callMethod("push", "test1")
-    await stringObject.callMethod("push", "test2")
-
-    const result = await stringObject.serialize()
-
-    expect(result).toEqual(["test1", "test2"])
-  })
-
-  it("returns results from method calls", async () => {
-    const stringObject = await shared.client.newObjectWithReference("Array")
-
-    await stringObject.callMethod("push", "test1")
-    await stringObject.callMethod("push", "test2")
-
-    const result = await stringObject.callMethod("join", ", ")
-
-    expect(result).toEqual("test1, test2")
-  })
-
-  it("handles errors from method calls", async () => {
-    const stringObject = await shared.client.newObjectWithReference("Array")
-
-    let caughtError = null
-
-    try {
-      await stringObject.callMethod("nonExistentMethod")
-    } catch (error) {
-      caughtError = error
-    }
-
-    expect(caughtError).toBeInstanceOf(Error)
-    expect(caughtError.message).toEqual("No method called 'nonExistentMethod' on a 'Array'")
-  })
-})

package/spec/web-socket-python-spec.js

@@ -1,57 +0,0 @@
-// @ts-check
-
-import Client from "../src/client/index.js"
-import ClientWebSocket from "../src/client/connections/web-socket/index.js"
-import Logger from "../src/logger.js"
-import PythonWebSocketRunner from "../src/python-web-socket-runner.js"
-import {WebSocket} from "ws"
-
-const shared = {}
-const logger = new Logger("Scoundrel WebSocket Python Spec")
-
-describe("scoundrel - web-socket - python", () => {
-  beforeEach(async () => {
-    logger.log("Starting Python with client")
-    shared.pythonWebSocketRunner = new PythonWebSocketRunner()
-
-    logger.log("Running Python WebSocket runner and waiting for PID")
-    await shared.pythonWebSocketRunner.runAndWaitForPid()
-
-    logger.log("Starting WebSocket client connection")
-    const ws = new WebSocket("ws://localhost:53874")
-
-    logger.log("Creating ClientWebSocket")
-    const clientWebSocket = new ClientWebSocket(ws)
-
-    logger.log("Waiting for WebSocket to open")
-    await clientWebSocket.waitForOpened()
-
-    logger.log("Creating Scoundrel Client")
-    shared.client = new Client(clientWebSocket)
-  })
-
-  afterEach(async () => {
-    shared.client?.close()
-    shared.pythonWebSocketRunner?.close()
-  })
-
-  it("creates a server and connects to it with the client", async () => {
-    const stringObject = await shared.client.newObjectWithReference("[]")
-
-    await stringObject.callMethod("append", "test1")
-    await stringObject.callMethod("append", "test2")
-
-    const result = await stringObject.serialize()
-
-    expect(result).toEqual(["test1", "test2"])
-  })
-
-  it("imports classes and uses them", async () => {
-    const math = await shared.client.import("math")
-    const pi = await math.readAttributeWithReference("pi")
-    const cosOfPi = await math.callMethodWithReference("cos", pi)
-    const result = await cosOfPi.serialize()
-
-    expect(result).toEqual(-1)
-  })
-})

package/src/client/connections/web-socket/index.js

@@ -1,88 +0,0 @@
-// @ts-check
-
-import Logger from "../../../logger.js"
-
-const logger = new Logger("Scoundrel WebSocket")
-
-// logger.setDebug(true)
-
-export default class WebSocket {
-  /**
-   * Creates a new WebSocket connection handler
-   * @param {WebSocket} ws The WebSocket instance
-   */
-  constructor(ws) {
-    this.ws = ws
-
-    // @ts-ignore
-    this.ws.addEventListener("error", this.onSocketError)
-
-    // @ts-ignore
-    this.ws.addEventListener("open", this.onSocketOpen)
-
-    // @ts-ignore
-    this.ws.addEventListener("message", this.onSocketMessage)
-
-    this.commands = {}
-    this.commandsCount = 0
-  }
-
-  async close() {
-    await this.ws.close()
-  }
-
-  /**
-   * @param {(data: any) => void} callback
-   */
-  onCommand(callback) {
-    this.onCommandCallback = callback
-  }
-
-  /**
-   * @param {Event} event
-   */
-  onSocketError = (event) => {
-    logger.error(() => ["onSocketError", event])
-  }
-
-  /**
-   * @param {MessageEvent} event
-   */
-  onSocketMessage = (event) => {
-    const data = JSON.parse(event.data)
-
-    logger.log(() => ["Client::Connections::WebSocket onSocketMessage", data])
-
-    if (!this.onCommandCallback) {
-      throw new Error("No onCommand callback set, ignoring message")
-    }
-
-    this.onCommandCallback(data)
-  }
-
-  /**
-   * @param {Event} _event
-   */
-  onSocketOpen = (_event) => { // eslint-disable-line no-unused-vars
-    logger.log("onSocketOpen")
-  }
-
-  /**
-   * @param {Record<string, any>} data
-   */
-  send(data) {
-    const sendData = JSON.stringify(data)
-    logger.log(() => ["Sending", sendData])
-
-    // @ts-ignore
-    this.ws.send(sendData)
-  }
-
-  waitForOpened = () => new Promise((resolve, reject) => {
-    // @ts-ignore
-    this.ws.addEventListener("open", resolve)
-
-    // @ts-ignore
-    this.ws.addEventListener("error", reject)
-  })
-}

package/src/client/index.js

@@ -1,469 +0,0 @@
-// @ts-check
-
-import Logger from "../logger.js"
-import Reference from "./reference.js"
-
-const logger = new Logger("Scoundrel Client")
-
-// logger.setDebug(true)
-
-export default class Client {
-  /**
-   * Creates a new Scoundrel Client
-   *
-   * @param {any} backend The backend connection (e.g., WebSocket)
-   */
-  constructor(backend) {
-    this.backend = backend
-    this.backend.onCommand(this.onCommand)
-
-    /** @type {Record<number, any>} */
-    this.outgoingCommands = {}
-    this.incomingCommands = {}
-    this.outgoingCommandsCount = 0
-
-    /** @type {Record<string, any>} */
-    this._classes = {}
-
-    /** @type {Record<string, any>} */
-    this._objects = {}
-
-    /** @type {Record<string, Reference>} */
-    this.references = {}
-
-    /** @type {Record<number, any>} */
-    this.objects = {}
-
-    this.objectsCount = 0
-  }
-
-  /**
-   * Closes the client connection
-   */
-  async close() {
-    this.backend.close()
-  }
-
-  /**
-   * Calls a method on a reference and returns the result directly
-   *
-   * @param {number} referenceId
-   * @param {string} methodName
-   * @param  {...any} args
-   * @returns {Promise<any>}
-   */
-  async callMethodOnReference(referenceId, methodName, ...args) {
-    const result = await this.sendCommand("call_method_on_reference", {
-      args: this.parseArg(args),
-      method_name: methodName,
-      reference_id: referenceId,
-      with: "result"
-    })
-
-    return result.response
-  }
-
-  /**
-   * Calls a method on a reference and returns a new reference
-   *
-   * @param {number} referenceId
-   * @param {string} methodName
-   * @param  {...any} args
-   * @returns {Promise<Reference>}
-   */
-  async callMethodOnReferenceWithReference(referenceId, methodName, ...args) {
-    const result = await this.sendCommand("call_method_on_reference", {
-      args: this.parseArg(args),
-      method_name: methodName,
-      reference_id: referenceId,
-      with: "reference"
-    })
-    const id = result.response
-
-    return this.spawnReference(id)
-  }
-
-  /**
-   * Evaluates a string and returns a new reference
-   *
-   * @param {string} evalString
-   * @returns {Promise<Reference>}
-   */
-  async evalWithReference(evalString) {
-    const result = await this.sendCommand("eval", {
-      eval_string: evalString,
-      with_reference: true
-    })
-    const id = result.object_id
-
-    return this.spawnReference(id)
-  }
-
-  /**
-   * Imports a module and returns a reference to it
-   *
-   * @param {string} importName
-   * @returns {Promise<Reference>}
-   */
-  async import(importName) {
-    const result = await this.sendCommand("import", {
-      import_name: importName
-    })
-
-    logger.log(() => ["import", {result}])
-
-    if (!result) throw new Error("No result given")
-    if (!result.object_id) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)
-
-    const id = result.object_id
-
-    return this.spawnReference(id)
-  }
-
-  /**
-   * Gets a registered object by name
-   *
-   * @param {string} objectName
-   * @returns {Promise<Reference>}
-   */
-  async getObject(objectName) {
-    const result = await this.sendCommand("get_object", {
-      object_name: objectName
-    })
-
-    if (!result) throw new Error("Blank result given")
-
-    const id = result.object_id
-
-    return this.spawnReference(id)
-  }
-
-  /**
-   * Spawns a new reference to an object
-   *
-   * @param {string} className
-   * @param  {...any} args
-   * @returns {Promise<Reference>}
-   */
-  async newObjectWithReference(className, ...args) {
-    const result = await this.sendCommand("new_object_with_reference", {
-      args: this.parseArg(args),
-      class_name: className
-    })
-
-    if (!result) throw new Error("Blank result given")
-
-    const id = result.object_id
-
-    if (!id) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)
-
-    return this.spawnReference(id)
-  }
-
-  /**
-   * Checks if the input is a plain object
-   * @param {any} input
-   * @returns {boolean}
-   */
-  isPlainObject(input) {
-    if (input && typeof input === "object" && !Array.isArray(input)) {
-      return true
-    }
-
-    return false
-  }
-
-  /**
-   * Handles an incoming command from the backend
-   * @param {object} args
-   * @param {string} args.command
-   * @param {number} args.command_id
-   * @param {any} args.data
-   * @param {string} [args.error]
-   * @param {string} [args.errorStack]
-   */
-  onCommand = ({command, command_id: commandID, data, error, errorStack, ...restArgs}) => {
-    logger.log(() => ["onCommand", {command, commandID, data, error, errorStack, restArgs}])
-
-    try {
-      if (!command) {
-        throw new Error(`No command key given in data: ${Object.keys(restArgs).join(", ")}`)
-      } else if (command == "get_object") {
-        const serverObject = this._getRegisteredObject(data.object_name)
-        let object
-
-        if (serverObject) {
-          object = serverObject
-        } else {
-          object = globalThis[data.object_name]
-
-          if (!object) throw new Error(`No such object: ${data.object_name}`)
-        }
-
-        const objectId = ++this.objectsCount
-
-        this.objects[objectId] = object
-        this.respondToCommand(commandID, {object_id: objectId})
-      } else if (command == "new_object_with_reference") {
-        const className = data.class_name
-        let object
-
-        if (typeof className == "string") {
-          const ClassInstance = this.getClass(className) || globalThis[className]
-
-          if (!ClassInstance) throw new Error(`No such class: ${className}`)
-
-          object = new ClassInstance(...data.args)
-        } else {
-          throw new Error(`Don't know how to handle class name: ${typeof className}`)
-        }
-
-        const objectId = ++this.objectsCount
-
-        this.objects[objectId] = object
-        this.respondToCommand(commandID, {object_id: objectId})
-      } else if (command == "call_method_on_reference") {
-        const referenceId = data.reference_id
-        const object = this.objects[referenceId]
-
-        if (!object) throw new Error(`No object by that ID: ${referenceId}`)
-
-        const method = object[data.method_name]
-
-        if (!method) throw new Error(`No method called '${data.method_name}' on a '${object.constructor.name}'`)
-
-        const response = method.call(object, ...data.args)
-
-        this.respondToCommand(commandID, {response})
-      } else if (command == "serialize_reference") {
-        const referenceId = data.reference_id
-        const object = this.objects[referenceId]
-
-        if (!object) throw new Error(`No object by that ID: ${referenceId}`)
-
-        this.respondToCommand(commandID, JSON.stringify(object))
-      } else if (command == "read_attribute") {
-        const attributeName = data.attribute_name
-        const referenceId = data.reference_id
-        const returnWith = data.with
-        const object = this.objects[referenceId]
-
-        if (!object) throw new Error(`No object by that ID: ${referenceId}`)
-
-        const attribute = object[attributeName]
-
-        if (returnWith == "reference") {
-          const objectId = ++this.objectsCount
-
-          this.objects[objectId] = attribute
-          this.respondToCommand(commandID, {response: objectId})
-        } else {
-          this.respondToCommand(commandID, {response: attribute})
-        }
-      } else if (command == "command_response") {
-        if (!(commandID in this.outgoingCommands)) {
-          throw new Error(`Outgoing command ${commandID} not found: ${Object.keys(this.outgoingCommands).join(", ")}`)
-        }
-
-        const savedCommand = this.outgoingCommands[commandID]
-
-        delete this.outgoingCommands[commandID]
-
-        if (error) {
-          const errorToThrow = new Error(error)
-
-          if (errorStack) {
-            errorToThrow.stack = `${errorStack}\n\n${errorToThrow.stack}`
-          }
-
-          savedCommand.reject(errorToThrow)
-        } else {
-          logger.log(() => [`Resolving command ${commandID} with data`, data])
-          savedCommand.resolve(data.data)
-        }
-      } else {
-        throw new Error(`Unknown command: ${command}`)
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        this.send({command: "command_response", command_id: commandID, error: error.message, errorStack: error.stack})
-      } else {
-        this.send({command: "command_response", command_id: commandID, error: String(error)})
-      }
-
-      logger.error(error)
-    }
-  }
-
-  /**
-   * Parases an argument for sending to the server
-   *
-   * @param {any} arg
-   * @returns {any}
-   */
-  parseArg(arg) {
-    if (Array.isArray(arg)) {
-      return arg.map((argInArray) => this.parseArg(argInArray))
-    } else if (arg instanceof Reference) {
-      return {
-        __scoundrel_object_id: arg.id,
-        __scoundrel_type: "reference"
-      }
-    } else if (this.isPlainObject(arg)) {
-      /** @type {Record<any, any>} */
-      const newObject = {}
-
-      for (const key in arg) {
-        const value = arg[key]
-
-        newObject[key] = this.parseArg(value)
-      }
-
-      return newObject
-    }
-
-    return arg
-  }
-
-  /**
-   * Reads an attribute on a reference and returns a new reference
-   *
-   * @param {number} referenceId
-   * @param {string} attributeName
-   * @returns {Promise<Reference>}
-   */
-  async readAttributeOnReferenceWithReference(referenceId, attributeName) {
-    const result = await this.sendCommand("read_attribute", {
-      attribute_name: attributeName,
-      reference_id: referenceId,
-      with: "reference"
-    })
-    const id = result.response
-
-    return this.spawnReference(id)
-  }
-
-  /**
-   * Reads an attribute on a reference and returns the result directly
-   *
-   * @param {number} referenceId
-   * @param {string} attributeName
-   * @returns {Promise<any>}
-   */
-  async readAttributeOnReference(referenceId, attributeName) {
-    const result = await this.sendCommand("read_attribute", {
-      attribute_name: attributeName,
-      reference_id: referenceId,
-      with: "result"
-    })
-    return result.response
-  }
-
-  /**
-   * Registers a class by name
-   *
-   * @param {string} className
-   * @param {any} classInstance
-   */
-  registerClass(className, classInstance) {
-    if (className in this._classes) throw new Error(`Class already exists: ${className}`)
-
-    this._classes[className] = classInstance
-  }
-
-  /**
-   * Gets a registered class by name
-   *
-   * @param {string} className
-   * @returns {any}
-   */
-  getClass(className) {
-    return this._classes[className]
-  }
-
-  /**
-   * Registers an object by name
-   *
-   * @param {string} objectName
-   * @param {any} objectInstance
-   */
-  registerObject(objectName, objectInstance) {
-    if (objectName in this._objects) throw new Error(`Object already exists: ${objectName}`)
-
-    this._objects[objectName] = objectInstance
-  }
-
-  /**
-   * Gets a registered object by name
-   *
-   * @param {string} objectName
-   * @returns {any}
-   */
-  _getRegisteredObject(objectName) {
-    return this._objects[objectName]
-  }
-
-  /**
-   * Responds to a command from the backend
-   * @param {number} commandId
-   * @param {any} data
-   */
-  respondToCommand(commandId, data) {
-    this.sendCommand("command_response", {command_id: commandId, data})
-  }
-
-  /**
-   * Sends a command to the backend and returns a promise that resolves with the response
-   * @param {string} command
-   * @param {any} data
-   * @returns {Promise<any>}
-   */
-  sendCommand(command, data) {
-    return new Promise((resolve, reject) => {
-      const outgoingCommandCount = ++this.outgoingCommandsCount
-      const commandData = {
-        command,
-        command_id: outgoingCommandCount,
-        data
-      }
-
-      this.outgoingCommands[outgoingCommandCount] = {resolve, reject}
-      logger.log(() => ["Sending", commandData])
-      this.send(commandData)
-    })
-  }
-
-  /**
-   * Sends data to the backend
-   * @param {any} data
-   */
-  send(data) {
-    this.backend.send(data)
-  }
-
-  /**
-   * Serializes a reference and returns the result directly
-   *
-   * @param {number} referenceId
-   * @returns {Promise<any>}
-   */
-  async serializeReference(referenceId) {
-    const json = await this.sendCommand("serialize_reference", {reference_id: referenceId})
-
-    return JSON.parse(json)
-  }
-
-  /**
-   * Spawns a new reference to an object
-   *
-   * @param {string} id
-   * @returns {Reference}
-   */
-  spawnReference(id) {
-    const reference = new Reference(this, id)
-
-    this.references[id] = reference
-
-    return reference
-  }
-}