@wandelbots/nova-js 3.9.0-pr.280.2a86180 → 3.9.0-pr.280.5d405fb

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wandelbots/nova-js",
   "type": "module",
-  "version": "3.9.0-pr.280.2a86180",
+  "version": "3.9.0-pr.280.5d405fb",
   "description": "Official JS client for the Wandelbots API",
   "sideEffects": false,
   "packageManager": "pnpm@11.1.3+sha512.c85357fe17ca12dd23dd7071822666dfd7e3cb76fe214e3370b5ea2fb34f2a231185509b63e717f3cd0acb38dd3f8d82bcd5e8172400ae678b70ea4fbed0896d",
@@ -31,10 +31,10 @@
     "lint": "biome check --error-on-warnings .",
     "format": "biome format . --write",
     "knip": "knip",
-    "build": "tsdown src/index.ts src/lib/deprecated/v1/index.ts src/lib/v2/index.ts --format esm,cjs --clean --sourcemap",
+    "build": "tsdown",
     "test": "pnpm run build && vitest run",
     "e2e": "vitest run --config vitest.e2e.config.ts",
-    "checks": "pnpm format && concurrently --group --timings --names audit,lint,tsc,knip,test \"pnpm audit\" \"pnpm lint\" \"pnpm tsc\" \"pnpm knip\" \"pnpm test\""
+    "checks": "pnpm format && pnpm build && concurrently --group --timings --names audit,lint,tsc,knip,test \"pnpm audit\" \"pnpm lint\" \"pnpm tsc\" \"pnpm knip\" \"vitest run\""
   },
   "repository": {
     "type": "git",
@@ -51,6 +51,7 @@
     "@biomejs/biome": "^2.4.15",
     "@types/lodash-es": "^4.17.12",
     "@types/node": "^25.9.1",
+    "@types/ws": "^8.18.1",
     "concurrently": "^9.2.1",
     "conventional-changelog-conventionalcommits": "^9.3.1",
     "knip": "^6.14.2",
@@ -59,6 +60,7 @@
     "semantic-release": "^25.0.3",
     "semantic-release-export-data": "^1.2.0",
     "tsdown": "^0.22.0",
+    "tsnapi": "^0.3.3",
     "typescript": "^6.0.3",
     "vite": "^8.0.14",
     "vitest": "^4.1.7",

package/src/lib/v2/Nova.ts

@@ -1,4 +1,3 @@
-/** biome-ignore-all lint/style/noNonNullAssertion: legacy code */
 import type { Configuration as BaseConfiguration } from "@wandelbots/nova-api/v2"
 import type { AxiosRequestConfig } from "axios"
 import axios, { isAxiosError } from "axios"
@@ -10,18 +9,13 @@ import { parseNovaInstanceUrl } from "../converters"
 import { NovaAPIClient } from "./NovaAPIClient"
 import { MockNovaInstance } from "./mock/MockNovaInstance"
 
-export type NovaClientConfig = {
+export type NovaConfig = {
   /**
    * Url of the deployed NOVA instance to connect to
    * e.g. https://saeattii.instance.wandelbots.io
    */
   instanceUrl: string
 
-  /**
-   * Id of the cell to connect to
-   */
-  cellId: string
-
   /**
    * Access token for Bearer authentication.
    * If running on a NOVA instance, this can be automatically retrieved from
@@ -36,13 +30,13 @@ export type NovaClientConfig = {
  */
 export class Nova {
   readonly api: NovaAPIClient
-  readonly config: NovaClientConfig
+  readonly config: NovaConfig
   readonly mock?: MockNovaInstance
   readonly instanceUrl: URL
   authPromise: Promise<string | null> | null = null
   accessToken: string | null = null
 
-  constructor(config: NovaClientConfig) {
+  constructor(config: NovaConfig) {
     this.config = config
     this.accessToken =
       config.accessToken ||
@@ -116,7 +110,7 @@ export class Nova {
       )
     }
 
-    this.api = new NovaAPIClient(this.config.cellId, {
+    this.api = new NovaAPIClient({
       ...config,
       basePath: urlJoin(this.instanceUrl.href, "/api/v2"),
       isJsonMime: (mime: string) => {
@@ -126,7 +120,10 @@ export class Nova {
         ...(this.mock
           ? ({
               adapter: (config) => {
-                return this.mock!.handleAPIRequest(config)
+                if (!this.mock) {
+                  throw new Error("Mock adapter used without a mock instance")
+                }
+                return this.mock.handleAPIRequest(config)
               },
             } satisfies AxiosRequestConfig)
           : {}),
@@ -165,13 +162,7 @@ export class Nova {
   }
 
   makeWebsocketURL(path: string): string {
-    const url = new URL(
-      urlJoin(
-        this.instanceUrl.href,
-        `/api/v2/cells/${this.config.cellId}`,
-        path,
-      ),
-    )
+    const url = new URL(urlJoin(this.instanceUrl.href, `/api/v2`, path))
     url.protocol = url.protocol.replace("http", "ws")
     url.protocol = url.protocol.replace("https", "wss")
 

package/src/lib/v2/NovaAPIClient.ts

@@ -1,43 +1,13 @@
-/** biome-ignore-all lint/suspicious/noExplicitAny: legacy code */
-/** biome-ignore-all lint/style/noNonNullAssertion: legacy code */
 import type {
   BaseAPI,
   Configuration as BaseConfiguration,
 } from "@wandelbots/nova-api/v2"
-import {
-  ApplicationApi,
-  BUSInputsOutputsApi,
-  CellApi,
-  ControllerApi,
-  ControllerInputsOutputsApi,
-  JoggingApi,
-  KinematicsApi,
-  LicenseApi,
-  MotionGroupApi,
-  MotionGroupModelsApi,
-  NOVACloudApi,
-  ProgramApi,
-  RobotConfigurationsApi,
-  StoreCollisionComponentsApi,
-  StoreCollisionSetupsApi,
-  StoreObjectApi,
-  SystemApi,
-  TrajectoryCachingApi,
-  TrajectoryExecutionApi,
-  TrajectoryPlanningApi,
-  VersionApi,
-  VirtualControllerApi,
-  VirtualControllerBehaviorApi,
-  VirtualControllerInputsOutputsApi,
-} from "@wandelbots/nova-api/v2"
+import * as novaApiV2 from "@wandelbots/nova-api/v2"
 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
+// biome-ignore lint/suspicious/noExplicitAny: metamagic
+type UnwrapAxiosResponseReturn<T> = T extends (...a: any[]) => any
   ? (
       ...a: Parameters<T>
     ) => Promise<Awaited<ReturnType<T>> extends { data: infer D } ? D : never>
@@ -48,107 +18,140 @@ type WithUnwrappedAxiosResponse<T> = {
 }
 
 /**
- * API client providing type-safe access to all the endpoints of a NOVA
- * instance.
+ * Filters nova-api/v2 exports to just the API class constructors,
+ * excluding helper factories and param creators.
  */
-export class NovaAPIClient {
-  constructor(
-    readonly cellId: string,
-    readonly opts: BaseConfiguration & {
-      axiosInstance?: AxiosInstance
-      mock?: boolean
-    },
-  ) {}
-
-  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>
-  }
-
-  readonly system = this.withUnwrappedResponsesOnly(SystemApi)
-  readonly cell = this.withUnwrappedResponsesOnly(CellApi)
-
-  readonly motionGroup = this.withUnwrappedResponsesOnly(MotionGroupApi)
-  readonly motionGroupModels =
-    this.withUnwrappedResponsesOnly(MotionGroupModelsApi)
-
-  readonly controller = this.withUnwrappedResponsesOnly(ControllerApi)
-
-  readonly controllerIOs = this.withUnwrappedResponsesOnly(
-    ControllerInputsOutputsApi,
-  )
-
-  readonly trajectoryPlanning = this.withUnwrappedResponsesOnly(
-    TrajectoryPlanningApi,
-  )
-  readonly trajectoryExecution = this.withUnwrappedResponsesOnly(
-    TrajectoryExecutionApi,
-  )
-  readonly trajectoryCaching =
-    this.withUnwrappedResponsesOnly(TrajectoryCachingApi)
-
-  readonly application = this.withUnwrappedResponsesOnly(ApplicationApi)
-  readonly applicationGlobal = this.withUnwrappedResponsesOnly(ApplicationApi)
+type ApiConstructors = {
+  [K in keyof typeof novaApiV2 as K extends `${string}Api`
+    ? K extends
+        | `${string}Factory${string}`
+        | `${string}Fp${string}`
+        | `${string}ParamCreator${string}`
+      ? never
+      : K
+    : never]: (typeof novaApiV2)[K]
+}
 
-  readonly jogging = this.withUnwrappedResponsesOnly(JoggingApi)
+/**
+ * Lowercases leading uppercase characters to produce a camelCase property name.
+ * e.g. "BUSInputsOutputs" -> "busInputsOutputs", "NOVACloud" -> "novaCloud",
+ *      "Application" -> "application"
+ */
+type CamelCase<S extends string> =
+  S extends `${Uppercase<infer A>}${Uppercase<infer B>}${infer Rest}`
+    ? Rest extends `${Lowercase<string>}${string}`
+      ? `${Lowercase<A>}${CamelCase<`${Uppercase<B>}${Rest}`>}`
+      : `${Lowercase<A>}${CamelCase<`${Uppercase<B>}${Rest}`>}`
+    : Uncapitalize<S>
 
-  readonly kinematics = this.withUnwrappedResponsesOnly(KinematicsApi)
+/**
+ * Maps API class names to property names by stripping "Api" and converting
+ * the leading acronym to lowercase camelCase.
+ */
+type ApiProperties = {
+  readonly [K in keyof ApiConstructors as K extends `${infer P}Api`
+    ? CamelCase<P>
+    : never]: ApiConstructors[K] extends new (
+    // biome-ignore lint/suspicious/noExplicitAny: needed for contravariant parameter matching
+    ...args: any[]
+  ) => infer I
+    ? WithUnwrappedAxiosResponse<I>
+    : never
+}
 
-  readonly busInputsOutputs =
-    this.withUnwrappedResponsesOnly(BUSInputsOutputsApi)
+type NovaAPIClientOpts = BaseConfiguration & {
+  axiosInstance?: AxiosInstance
+  mock?: boolean
+}
 
-  readonly virtualController =
-    this.withUnwrappedResponsesOnly(VirtualControllerApi)
-  readonly virtualControllerBehavior = this.withUnwrappedResponsesOnly(
-    VirtualControllerBehaviorApi,
-  )
-  readonly virtualControllerIOs = this.withUnwrappedResponsesOnly(
-    VirtualControllerInputsOutputsApi,
+function isApiClass(
+  name: string,
+  value: unknown,
+): value is new (
+  config: BaseConfiguration,
+  basePath: string,
+  axios: AxiosInstance,
+) => BaseAPI {
+  return (
+    name.endsWith("Api") &&
+    typeof value === "function" &&
+    !name.includes("Factory") &&
+    !name.includes("Fp") &&
+    !name.includes("ParamCreator")
   )
+}
 
-  readonly storeObject = this.withUnwrappedResponsesOnly(StoreObjectApi)
-  readonly storeCollisionComponents = this.withUnwrappedResponsesOnly(
-    StoreCollisionComponentsApi,
-  )
-  readonly storeCollisionSetups = this.withUnwrappedResponsesOnly(
-    StoreCollisionSetupsApi,
-  )
+function wrapApi<T extends BaseAPI>(
+  ApiConstructor: new (
+    config: BaseConfiguration,
+    basePath: string,
+    axios: AxiosInstance,
+  ) => T,
+  opts: NovaAPIClientOpts,
+): WithUnwrappedAxiosResponse<T> {
+  const apiClient = new ApiConstructor(
+    {
+      ...opts,
+      isJsonMime: (mime: string) => mime === "application/json",
+    },
+    opts.basePath ?? "",
+    opts.axiosInstance ?? axios.create(),
+  ) as Record<string | symbol, unknown>
+
+  for (const key of Reflect.ownKeys(
+    Reflect.getPrototypeOf(apiClient) as object,
+  )) {
+    if (key !== "constructor" && typeof apiClient[key] === "function") {
+      const originalFunction = apiClient[key] as (
+        ...args: unknown[]
+      ) => Promise<{ data: unknown }>
+      apiClient[key] = (...args: unknown[]) =>
+        originalFunction.apply(apiClient, args).then((res) => res.data)
+    }
+  }
 
-  readonly program = this.withUnwrappedResponsesOnly(ProgramApi)
+  return apiClient as WithUnwrappedAxiosResponse<T>
+}
 
-  readonly license = this.withUnwrappedResponsesOnly(LicenseApi)
-  readonly novaCloud = this.withUnwrappedResponsesOnly(NOVACloudApi)
-  readonly robotConfigurations = this.withUnwrappedResponsesOnly(
-    RobotConfigurationsApi,
-  )
-  readonly version = this.withUnwrappedResponsesOnly(VersionApi)
+/**
+ * API client providing type-safe access to all the endpoints of a NOVA
+ * instance. API sections are auto-discovered from @wandelbots/nova-api/v2
+ * at runtime, so new sections added upstream are exposed automatically.
+ */
+export const NovaAPIClient = class NovaAPIClient {
+  readonly opts: NovaAPIClientOpts
+
+  constructor(opts: NovaAPIClientOpts) {
+    this.opts = opts
+
+    for (const [name, value] of Object.entries(novaApiV2)) {
+      if (isApiClass(name, value)) {
+        const stripped = name.slice(0, -3)
+        // Lowercase leading acronym run: "BUSInputsOutputs" -> "busInputsOutputs"
+        let i = 0
+        while (
+          i < stripped.length &&
+          stripped[i] === stripped[i].toUpperCase() &&
+          stripped[i] !== stripped[i].toLowerCase()
+        ) {
+          i++
+        }
+        // If multiple uppercase chars, keep the last one uppercase (it starts the next word)
+        const boundary = i > 1 ? i - 1 : i
+        const propName =
+          stripped.slice(0, boundary).toLowerCase() + stripped.slice(boundary)
+        // biome-ignore lint/suspicious/noExplicitAny: dynamically assigning discovered API properties
+        ;(this as any)[propName] = wrapApi(value, opts)
+      }
+    }
+  }
+} as {
+  new (
+    opts: NovaAPIClientOpts,
+  ): ApiProperties & {
+    readonly cellId: string
+    readonly opts: NovaAPIClientOpts
+  }
 }
+
+export type NovaAPIClient = InstanceType<typeof NovaAPIClient>

package/src/lib/v2/index.ts

@@ -3,5 +3,5 @@ export * from "../deprecated/v2/NovaCellAPIClient"
 export * from "../deprecated/v2/NovaClient"
 export * from "../deprecated/v2/wandelscriptUtils"
 export { Nova } from "./Nova"
-export type { NovaClientConfig } from "./Nova"
+export type { NovaConfig } from "./Nova"
 export { NovaAPIClient } from "./NovaAPIClient"