@truenas/api-client 2.0.1 → 3.0.1

package/dist/index.cjs

@@ -2521,7 +2521,6 @@ __export(v26_0_0_exports, {
   Aclmode: () => Aclmode,
   Acltype: () => Acltype,
   Advpowermgmt: () => Advpowermgmt,
-  Algorithm: () => Algorithm,
   AppContainerDetailsState: () => AppContainerDetailsState,
   AppContainerDetailsStateInput: () => AppContainerDetailsStateInput,
   Atime: () => Atime,
@@ -2659,11 +2658,13 @@ var ContainerNICDeviceTypeInput = {
 };
 var ContainerStatusState = {
   Running: "RUNNING",
-  Stopped: "STOPPED"
+  Stopped: "STOPPED",
+  Suspended: "SUSPENDED"
 };
 var ContainerStatusStateInput = {
   Running: "RUNNING",
-  Stopped: "STOPPED"
+  Stopped: "STOPPED",
+  Suspended: "SUSPENDED"
 };
 var Feature2 = {
   Apps: "APPS",
@@ -2743,7 +2744,6 @@ __export(v27_0_0_exports, {
   Aclmode: () => Aclmode,
   Acltype: () => Acltype,
   Advpowermgmt: () => Advpowermgmt,
-  Algorithm: () => Algorithm,
   AppContainerDetailsState: () => AppContainerDetailsState,
   AppContainerDetailsStateInput: () => AppContainerDetailsStateInput,
   Atime: () => Atime,
@@ -2894,14 +2894,23 @@ var apiVersionConfig = {
   /**
    * Maximum supported API version. Systems above it are rejected.
    *
-   * NOT derived, deliberately. This should be the newest generated version by
-   * the same argument as MIN, but `instantiateClientForVersion` only maps
-   * `25.10` and `26` — a v27 system would pass the range check and then throw
-   * on client selection. It moves to the newest generated version once a v27
-   * client exists. Until then it lags on purpose, and the `satisfies` clause
-   * below still pins it to a version that was actually generated.
+   * NOT derived, deliberately — and for a different reason than it used to
+   * lag. It sat at v26.0.0 while types for v27 already shipped, because
+   * `CLIENT_BY_VERSION_KEY` had no `27` and a v27 system would have passed the
+   * range check only to throw on client selection. `TrueNasApiClientV27` now
+   * exists, so this moves up with it.
+   *
+   * What it must not become is `SUPPORTED_API_VERSIONS[length - 1]`, the mirror
+   * of how MIN is derived. MIN is safe to derive because the oldest generated
+   * version always has a client — it is the floor the clients were built from.
+   * The ceiling is not symmetric: generating types for v28 does not write a v28
+   * client, so deriving this would re-create the exact gap described above on
+   * the next regeneration, silently. The real invariant is "the newest version
+   * a client can be built for", which lives in `CLIENT_BY_VERSION_KEY`; a
+   * factory test asserts the two agree, which is the check that keeps this
+   * literal honest without importing the factory here.
    */
-  MAX_SUPPORTED_VERSION: "v26.0.0",
+  MAX_SUPPORTED_VERSION: "v27.0.0",
   /**
    * Fallback version to use when version discovery fails due to CORS/network errors.
    * When /api/versions returns HTTP status 0 (CORS block, network down, etc.),
@@ -3066,6 +3075,10 @@ var AppState = /* @__PURE__ */ ((AppState2) => {
   AppState2["Stopped"] = "STOPPED";
   AppState2["Stopping"] = "STOPPING";
   AppState2["Deploying"] = "DEPLOYING";
+  AppState2["Suspended"] = "SUSPENDED";
+  AppState2["Suspending"] = "SUSPENDING";
+  AppState2["Error"] = "ERROR";
+  AppState2["Unknown"] = "UNKNOWN";
   return AppState2;
 })(AppState || {});
 
@@ -3076,7 +3089,10 @@ function toAppState(state) {
       return "RUNNING" /* Running */;
     case "STOPPED":
       return "STOPPED" /* Stopped */;
+    // `ABORTING` is v25.10 only: the instance is being forced down, which ends
+    // at `STOPPED` and is what `Stopping` already means.
     case "STOPPING":
+    case "ABORTING":
       return "STOPPING" /* Stopping */;
     // `STARTING` is v25.10 `virt.instance` only, and folding it into `Stopped`
     // told callers a container that is coming up is at rest — enough for a UI
@@ -3085,8 +3101,35 @@ function toAppState(state) {
     case "STARTING":
     case "DEPLOYING":
       return "DEPLOYING" /* Deploying */;
+    // v25.10's freezer states are the same idea as v26's `SUSPENDED`: the
+    // processes are paused, not exited. `FROZEN` is that pause completed, so it
+    // and `SUSPENDED` are the same answer.
+    case "SUSPENDED":
+    case "FROZEN":
+      return "SUSPENDED" /* Suspended */;
+    // `FREEZING` is on the way there and not there yet. It used to answer
+    // `Suspended`, defended by analogy with `STARTING` — but `STARTING` maps to
+    // `Deploying`, which is itself an in-progress word, so the analogy ran the
+    // wrong way. Answering `Suspended` tells a caller polling for "the memory
+    // is quiesced" that it is, one poll before it is true: the same false
+    // claim this mapping was rewritten to stop making, one state along.
+    // `ABORTING` had `Stopping` to land on; the freeze path needed its own.
+    case "FREEZING":
+      return "SUSPENDING" /* Suspending */;
+    // `THAWED` is the freezer lifted: the processes are scheduled again, so
+    // this is `RUNNING` reported through the transition rather than a state a
+    // caller should act on differently.
+    case "THAWED":
+      return "RUNNING" /* Running */;
+    case "ERROR":
+      return "ERROR" /* Error */;
+    // `UNKNOWN` is middleware's own word for it, and anything unrecognised is
+    // the same situation: a state this mapping has no word for. Neither is
+    // evidence the container is stopped.
+    case "UNKNOWN":
+      return "UNKNOWN" /* Unknown */;
     default:
-      return "STOPPED" /* Stopped */;
+      return "UNKNOWN" /* Unknown */;
   }
 }
 
@@ -3190,6 +3233,68 @@ function toContainer2(container) {
     description
   };
 }
+var TrueNasApiClientV27 = class extends TrueNasApiClient {
+  /**
+   * Create v27-specific operation mappings
+   *
+   * Operations return Observable<Job | null>:
+   * - Async operations emit Job updates until complete
+   * - Sync operations emit null once
+   */
+  createOperations() {
+    return {
+      // A polymorphic `.query`, so it goes through the verb rather than
+      // `call`: the directory types the raw method's response as the five-way
+      // union the server may return, and the verb is what fixes it to a list.
+      containerQuery: () => this.api.query("container.query").pipe(
+        rxjs.map((containers) => containers.map(toContainer3))
+      ),
+      // container.start is synchronous in v27 - emit null
+      containerStart: (id) => this.api.call("container.start", [parseInt(id, 10)]).pipe(rxjs.map(() => null)),
+      // container.stop emits job updates
+      containerStop: (id, options) => this.api.job("container.stop", [
+        parseInt(id, 10),
+        {
+          force: options.force,
+          force_after_timeout: options.force
+        }
+      ]),
+      // v27 still has no container.restart - chain stop + start.
+      // Emits Job updates during stop, then null when start completes.
+      containerRestart: (id, options) => {
+        const numericId = parseInt(id, 10);
+        return this.api.job("container.stop", [
+          numericId,
+          {
+            force: options.force,
+            force_after_timeout: options.force
+          }
+        ]).pipe(
+          // Collect all job updates to ensure stop fully completes
+          rxjs.toArray(),
+          // Re-emit job updates, then call start after stop is done
+          rxjs.switchMap(
+            (jobUpdates) => rxjs.concat(
+              rxjs.from(jobUpdates),
+              this.api.call("container.start", [numericId]).pipe(rxjs.map(() => null))
+            )
+          )
+        );
+      }
+    };
+  }
+};
+function toContainer3(container) {
+  const { description } = container;
+  return {
+    id: container.id.toString(),
+    name: container.name,
+    status: toAppState(container.status.state),
+    // Optional in the generated entry, required by `Container`.
+    autostart: container.autostart ?? false,
+    description
+  };
+}
 
 // src/errors/version-discovery.errors.ts
 var VersionDiscoveryError = class extends Error {
@@ -3559,7 +3664,8 @@ function selectRepresentativeFailure(failures) {
 }
 var CLIENT_BY_VERSION_KEY = {
   "25.10": TrueNasApiClientV2510,
-  "26": TrueNasApiClientV26
+  "26": TrueNasApiClientV26,
+  "27": TrueNasApiClientV27
 };
 function clientVersionKey(version) {
   if (version.year <= legacyCutoffYear) {
@@ -3615,6 +3721,7 @@ exports.SUPPORTED_API_VERSIONS = SUPPORTED_API_VERSIONS;
 exports.TrueNasApiClient = TrueNasApiClient;
 exports.TrueNasApiClientV2510 = TrueNasApiClientV2510;
 exports.TrueNasApiClientV26 = TrueNasApiClientV26;
+exports.TrueNasApiClientV27 = TrueNasApiClientV27;
 exports.TrueNasAuthMechanism = TrueNasAuthMechanism;
 exports.VersionCompatibility = VersionCompatibility;
 exports.VersionDiscovery = VersionDiscovery;