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

package/src/lib/v2/NovaAPIClient.ts

@@ -1,43 +1,12 @@
-/** 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
+type UnwrapAxiosResponseReturn<T> = T extends (...a: unknown[]) => unknown[]
   ? (
       ...a: Parameters<T>
     ) => Promise<Awaited<ReturnType<T>> extends { data: infer D } ? D : never>
@@ -48,107 +17,142 @@ 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.
+ *
+ * Properties are auto-discovered from the upstream package at runtime,
+ * so new API sections are available immediately without code changes.
+ */
+type ApiProperties = {
+  readonly [K in keyof ApiConstructors as K extends `${infer P}Api`
+    ? CamelCase<P>
+    : never]: ApiConstructors[K] extends new (
+    ...args: unknown[]
+  ) => 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>