@wandelbots/nova-js 3.13.0 → 4.0.0-pr.309.02b99fd

package/src/lib/deprecated/v1/NovaCellAPIClient.ts

@@ -1,208 +0,0 @@
-/** biome-ignore-all lint/style/noNonNullAssertion: legacy code */
-/** biome-ignore-all lint/suspicious/noExplicitAny: legacy code */
-import type {
-  BaseAPI,
-  Configuration as BaseConfiguration,
-} from "@wandelbots/nova-api/v1"
-import {
-  ApplicationApi,
-  CellApi,
-  ControllerApi,
-  ControllerIOsApi,
-  CoordinateSystemsApi,
-  DeviceConfigurationApi,
-  LibraryProgramApi,
-  LibraryProgramMetadataApi,
-  LibraryRecipeApi,
-  LibraryRecipeMetadataApi,
-  MotionApi,
-  MotionGroupApi,
-  MotionGroupInfosApi,
-  MotionGroupJoggingApi,
-  MotionGroupKinematicApi,
-  ProgramApi,
-  ProgramValuesApi,
-  StoreCollisionComponentsApi,
-  StoreCollisionScenesApi,
-  StoreObjectApi,
-  SystemApi,
-  VirtualRobotApi,
-  VirtualRobotBehaviorApi,
-  VirtualRobotModeApi,
-  VirtualRobotSetupApi,
-} from "@wandelbots/nova-api/v1"
-import type { AxiosInstance } from "axios"
-import axios from "axios"
-
-type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R
-  ? (...args: P) => R
-  : never
-
-type UnwrapAxiosResponseReturn<T> = T extends (...a: any) => any
-  ? (
-      ...a: Parameters<T>
-    ) => Promise<Awaited<ReturnType<T>> extends { data: infer D } ? D : never>
-  : never
-
-/** @deprecated Use `NovaAPIClient` instead. */
-export type WithCellId<T> = {
-  [P in keyof T]: UnwrapAxiosResponseReturn<OmitFirstArg<T[P]>>
-}
-
-/** @deprecated Use `NovaAPIClient` instead. */
-export type WithUnwrappedAxiosResponse<T> = {
-  [P in keyof T]: UnwrapAxiosResponseReturn<T[P]>
-}
-
-/**
- * API client providing type-safe access to all the Nova API REST endpoints
- * associated with a specific cell id.
- * @deprecated Use `NovaAPIClient` from `@wandelbots/nova-js/v2` instead.
- */
-export class NovaCellAPIClient {
-  readonly system: WithUnwrappedAxiosResponse<SystemApi>
-  readonly cell: WithUnwrappedAxiosResponse<CellApi>
-  readonly deviceConfig: WithCellId<DeviceConfigurationApi>
-  readonly motionGroup: WithCellId<MotionGroupApi>
-  readonly motionGroupInfos: WithCellId<MotionGroupInfosApi>
-  readonly controller: WithCellId<ControllerApi>
-  readonly program: WithCellId<ProgramApi>
-  readonly programValues: WithCellId<ProgramValuesApi>
-  readonly controllerIOs: WithCellId<ControllerIOsApi>
-  readonly motionGroupKinematic: WithCellId<MotionGroupKinematicApi>
-  readonly motion: WithCellId<MotionApi>
-  readonly coordinateSystems: WithCellId<CoordinateSystemsApi>
-  readonly application: WithCellId<ApplicationApi>
-  readonly applicationGlobal: WithUnwrappedAxiosResponse<ApplicationApi>
-  readonly motionGroupJogging: WithCellId<MotionGroupJoggingApi>
-  readonly virtualRobot: WithCellId<VirtualRobotApi>
-  readonly virtualRobotSetup: WithCellId<VirtualRobotSetupApi>
-  readonly virtualRobotMode: WithCellId<VirtualRobotModeApi>
-  readonly virtualRobotBehavior: WithCellId<VirtualRobotBehaviorApi>
-  readonly libraryProgramMetadata: WithCellId<LibraryProgramMetadataApi>
-  readonly libraryProgram: WithCellId<LibraryProgramApi>
-  readonly libraryRecipeMetadata: WithCellId<LibraryRecipeMetadataApi>
-  readonly libraryRecipe: WithCellId<LibraryRecipeApi>
-  readonly storeObject: WithCellId<StoreObjectApi>
-  readonly storeCollisionComponents: WithCellId<StoreCollisionComponentsApi>
-  readonly storeCollisionScenes: WithCellId<StoreCollisionScenesApi>
-
-  readonly cellId: string
-  readonly opts: BaseConfiguration & {
-    axiosInstance?: AxiosInstance
-    mock?: boolean
-  }
-
-  constructor(
-    cellId: string,
-    opts: BaseConfiguration & {
-      axiosInstance?: AxiosInstance
-      mock?: boolean
-    },
-  ) {
-    this.cellId = cellId
-    this.opts = opts
-    this.system = this.withUnwrappedResponsesOnly(SystemApi)
-    this.cell = this.withUnwrappedResponsesOnly(CellApi)
-    this.deviceConfig = this.withCellId(DeviceConfigurationApi)
-    this.motionGroup = this.withCellId(MotionGroupApi)
-    this.motionGroupInfos = this.withCellId(MotionGroupInfosApi)
-    this.controller = this.withCellId(ControllerApi)
-    this.program = this.withCellId(ProgramApi)
-    this.programValues = this.withCellId(ProgramValuesApi)
-    this.controllerIOs = this.withCellId(ControllerIOsApi)
-    this.motionGroupKinematic = this.withCellId(MotionGroupKinematicApi)
-    this.motion = this.withCellId(MotionApi)
-    this.coordinateSystems = this.withCellId(CoordinateSystemsApi)
-    this.application = this.withCellId(ApplicationApi)
-    this.applicationGlobal = this.withUnwrappedResponsesOnly(ApplicationApi)
-    this.motionGroupJogging = this.withCellId(MotionGroupJoggingApi)
-    this.virtualRobot = this.withCellId(VirtualRobotApi)
-    this.virtualRobotSetup = this.withCellId(VirtualRobotSetupApi)
-    this.virtualRobotMode = this.withCellId(VirtualRobotModeApi)
-    this.virtualRobotBehavior = this.withCellId(VirtualRobotBehaviorApi)
-    this.libraryProgramMetadata = this.withCellId(LibraryProgramMetadataApi)
-    this.libraryProgram = this.withCellId(LibraryProgramApi)
-    this.libraryRecipeMetadata = this.withCellId(LibraryRecipeMetadataApi)
-    this.libraryRecipe = this.withCellId(LibraryRecipeApi)
-    this.storeObject = this.withCellId(StoreObjectApi)
-    this.storeCollisionComponents = this.withCellId(StoreCollisionComponentsApi)
-    this.storeCollisionScenes = this.withCellId(StoreCollisionScenesApi)
-  }
-
-  /**
-   * Some TypeScript sorcery which alters the API class methods so you don't
-   * have to pass the cell id to every single one, and de-encapsulates the
-   * response data
-   */
-  private withCellId<T extends BaseAPI>(
-    ApiConstructor: new (
-      config: BaseConfiguration,
-      basePath: string,
-      axios: AxiosInstance,
-    ) => T,
-  ) {
-    const apiClient = new ApiConstructor(
-      {
-        ...this.opts,
-        isJsonMime: (mime: string) => {
-          return mime === "application/json"
-        },
-      },
-      this.opts.basePath ?? "",
-      this.opts.axiosInstance ?? axios.create(),
-    ) as {
-      [key: string | symbol]: any
-    }
-
-    for (const key of Reflect.ownKeys(Reflect.getPrototypeOf(apiClient)!)) {
-      if (key !== "constructor" && typeof apiClient[key] === "function") {
-        const originalFunction = apiClient[key]
-        apiClient[key] = (...args: any[]) => {
-          return originalFunction
-            .apply(apiClient, [this.cellId, ...args])
-            .then((res: any) => res.data)
-        }
-      }
-    }
-
-    return apiClient as WithCellId<T>
-  }
-
-  /**
-   * As withCellId, but only does the response unwrapping
-   */
-  private withUnwrappedResponsesOnly<T extends BaseAPI>(
-    ApiConstructor: new (
-      config: BaseConfiguration,
-      basePath: string,
-      axios: AxiosInstance,
-    ) => T,
-  ) {
-    const apiClient = new ApiConstructor(
-      {
-        ...this.opts,
-        isJsonMime: (mime: string) => {
-          return mime === "application/json"
-        },
-      },
-      this.opts.basePath ?? "",
-      this.opts.axiosInstance ?? axios.create(),
-    ) as {
-      [key: string | symbol]: any
-    }
-
-    for (const key of Reflect.ownKeys(Reflect.getPrototypeOf(apiClient)!)) {
-      if (key !== "constructor" && typeof apiClient[key] === "function") {
-        const originalFunction = apiClient[key]
-        apiClient[key] = (...args: any[]) => {
-          return originalFunction
-            .apply(apiClient, args)
-            .then((res: any) => res.data)
-        }
-      }
-    }
-
-    return apiClient as WithUnwrappedAxiosResponse<T>
-  }
-}

package/src/lib/deprecated/v1/NovaClient.ts

@@ -1,260 +0,0 @@
-/**
- * @fileoverview
- * @deprecated The nova v1 client is deprecated. Please use the v2 client from `@wandelbots/nova-js/v2` instead.
- */
-
-import type { Configuration as BaseConfiguration } from "@wandelbots/nova-api/v1"
-import type { AxiosRequestConfig } from "axios"
-import axios, { isAxiosError } from "axios"
-import { AutoReconnectingWebsocket } from "../../AutoReconnectingWebsocket.ts"
-import { loginWithAuth0 } from "../../LoginWithAuth0.ts"
-import { availableStorage } from "../../availableStorage.ts"
-import { parseNovaInstanceUrl } from "../../converters.ts"
-import { guardedPageReload } from "../../errorHandling.ts"
-
-import { isBrowser, isLocalhostDev } from "../../context.ts"
-import { ConnectedMotionGroup } from "./ConnectedMotionGroup.ts"
-import { JoggerConnection } from "./JoggerConnection.ts"
-import { MotionStreamConnection } from "./MotionStreamConnection.ts"
-import { NovaCellAPIClient } from "./NovaCellAPIClient.ts"
-import { MockNovaInstance } from "./mock/MockNovaInstance.ts"
-
-/** @deprecated Use `NovaConfig` from `@wandelbots/nova-js/v2` instead. */
-export type NovaClientConfig = {
-  /**
-   * Url of the deployed Nova instance to connect to
-   * e.g. https://saeattii.instance.wandelbots.io
-   */
-  instanceUrl: string | "https://mock.example.com"
-
-  /**
-   * Identifier of the cell on the Nova instance to connect this client to.
-   * If omitted, the default identifier "cell" is used.
-   **/
-  cellId?: string
-
-  /**
-   * Username for basic auth to the Nova instance.
-   * @deprecated use accessToken instead
-   */
-  username?: string
-
-  /**
-   * Password for basic auth to the Nova instance.
-   * @deprecated use accessToken instead
-   */
-  password?: string
-
-  /**
-   * Access token for Bearer authentication.
-   */
-  accessToken?: string
-} & Omit<BaseConfiguration, "isJsonMime" | "basePath">
-
-type NovaClientConfigWithDefaults = NovaClientConfig & { cellId: string }
-
-/**
- * Client for connecting to a Nova instance and controlling robots.
- * @deprecated The nova v1 client is deprecated. Please use the v2 client from `@wandelbots/nova-js/v2` instead.
- */
-export class NovaClient {
-  readonly api: NovaCellAPIClient
-  readonly config: NovaClientConfigWithDefaults
-  readonly mock?: MockNovaInstance
-  readonly instanceUrl: URL
-  authPromise: Promise<string | null> | null = null
-  accessToken: string | null = null
-
-  constructor(config: NovaClientConfig) {
-    const cellId = config.cellId ?? "cell"
-    this.config = {
-      cellId,
-      ...config,
-    }
-    this.accessToken =
-      config.accessToken ||
-      availableStorage.getString("wbjs.access_token") ||
-      null
-
-    if (this.config.instanceUrl === "https://mock.example.com") {
-      this.mock = new MockNovaInstance()
-    }
-    this.instanceUrl = parseNovaInstanceUrl(this.config.instanceUrl)
-
-    // Set up Axios instance with interceptor for token fetching
-    const axiosInstance = axios.create({
-      baseURL: new URL("/api/v1", this.config.instanceUrl).href,
-      // TODO - backend needs to set proper CORS headers for this
-      headers: isLocalhostDev
-        ? {}
-        : {
-            // Identify the client to the backend for logging purposes
-            "X-Wandelbots-Client": "Wandelbots-Nova-JS-SDK",
-          },
-    })
-
-    axiosInstance.interceptors.request.use(async (request) => {
-      if (!request.headers.Authorization) {
-        if (this.accessToken) {
-          request.headers.Authorization = `Bearer ${this.accessToken}`
-        } else if (this.config.username && this.config.password) {
-          request.headers.Authorization = `Basic ${btoa(`${config.username}:${config.password}`)}`
-        }
-      }
-      return request
-    })
-
-    if (isBrowser) {
-      axiosInstance.interceptors.response.use(
-        (r) => r,
-        async (error) => {
-          if (isAxiosError(error)) {
-            if (error.response?.status === 401) {
-              // If we hit a 401, attempt to login the user and retry with
-              // a new access token
-              try {
-                await this.renewAuthentication()
-
-                if (error.config) {
-                  if (this.accessToken) {
-                    error.config.headers.Authorization = `Bearer ${this.accessToken}`
-                  } else {
-                    delete error.config.headers.Authorization
-                  }
-                  return axiosInstance.request(error.config)
-                }
-              } catch (err) {
-                return Promise.reject(err)
-              }
-            } else if (error.response?.status === 503) {
-              // Check if the server as a whole is down
-              const res = await fetch(window.location.href)
-              if (res.status === 503) {
-                // Go to 503 page
-                return guardedPageReload("503_server_unavailable")
-              }
-            }
-          }
-
-          return Promise.reject(error)
-        },
-      )
-    }
-
-    this.api = new NovaCellAPIClient(cellId, {
-      ...config,
-      basePath: new URL("/api/v1", this.instanceUrl).href,
-      isJsonMime: (mime: string) => {
-        return mime === "application/json"
-      },
-      baseOptions: {
-        ...(this.mock
-          ? ({
-              adapter: (config) => {
-                // biome-ignore lint/style/noNonNullAssertion: legacy code
-                return this.mock!.handleAPIRequest(config)
-              },
-            } satisfies AxiosRequestConfig)
-          : {}),
-        ...config.baseOptions,
-      },
-      axiosInstance,
-    })
-  }
-
-  async renewAuthentication(): Promise<void> {
-    if (this.authPromise) {
-      // Don't double up
-      return
-    }
-
-    const storedToken = availableStorage.getString("wbjs.access_token")
-    if (storedToken && this.accessToken !== storedToken) {
-      // Might be newer than the one we have
-      this.accessToken = storedToken
-      return
-    }
-
-    // Otherwise, perform login flow
-    this.authPromise = loginWithAuth0(this.instanceUrl)
-    try {
-      this.accessToken = await this.authPromise
-      if (this.accessToken) {
-        // Cache access token so we don't need to log in every refresh
-        availableStorage.setString("wbjs.access_token", this.accessToken)
-      } else {
-        availableStorage.delete("wbjs.access_token")
-      }
-    } finally {
-      this.authPromise = null
-    }
-  }
-
-  makeWebsocketURL(path: string): string {
-    const url = new URL(
-      new URL(
-        `/api/v1/cells/${this.config.cellId}/${path.replace(/^\/+/, "")}`,
-        this.instanceUrl,
-      ).href,
-    )
-    url.protocol = url.protocol.replace("http", "ws")
-    url.protocol = url.protocol.replace("https", "wss")
-
-    // If provided, add basic auth credentials to the URL
-    // NOTE - basic auth is deprecated on websockets and doesn't work in Safari
-    // use tokens instead
-    if (this.accessToken) {
-      url.searchParams.append("token", this.accessToken)
-    } else if (this.config.username && this.config.password) {
-      url.username = this.config.username
-      url.password = this.config.password
-    }
-
-    return url.toString()
-  }
-
-  /**
-   * Retrieve an AutoReconnectingWebsocket to the given path on the Nova instance.
-   * If you explicitly want to reconnect an existing websocket, call `reconnect`
-   * on the returned object.
-   */
-  openReconnectingWebsocket(path: string) {
-    return new AutoReconnectingWebsocket(this.makeWebsocketURL(path), {
-      mock: this.mock,
-    })
-  }
-
-  /**
-   * Connect to the motion state websocket(s) for a given motion group
-   */
-  async connectMotionStream(motionGroupId: string) {
-    return await MotionStreamConnection.open(this, motionGroupId)
-  }
-
-  /**
-   * Connect to the jogging websocket(s) for a given motion group
-   */
-  async connectJogger(motionGroupId: string) {
-    return await JoggerConnection.open(this, motionGroupId)
-  }
-
-  async connectMotionGroups(
-    motionGroupIds: string[],
-  ): Promise<ConnectedMotionGroup[]> {
-    const { instances } = await this.api.controller.listControllers()
-
-    return Promise.all(
-      motionGroupIds.map((motionGroupId) =>
-        ConnectedMotionGroup.connect(this, motionGroupId, instances),
-      ),
-    )
-  }
-
-  async connectMotionGroup(
-    motionGroupId: string,
-  ): Promise<ConnectedMotionGroup> {
-    const motionGroups = await this.connectMotionGroups([motionGroupId])
-    // biome-ignore lint/style/noNonNullAssertion: legacy code
-    return motionGroups[0]!
-  }
-}