@calimero-network/mero-js 2.2.1 → 2.4.0

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   WsClient: () => WsClient,
   buildAuthLoginUrl: () => buildAuthLoginUrl,
   combineSignals: () => combineSignals,
+  compareSemver: () => compareSemver,
   createAdminApiClient: () => createAdminApiClient,
   createAdminApiClientFromHttpClient: () => createAdminApiClientFromHttpClient,
   createAuthApiClient: () => createAuthApiClient,
@@ -697,6 +698,24 @@ function createAuthApiClientFromHttpClient(httpClient, _config) {
 function unwrap(response) {
   return response.data;
 }
+function compareSemver(a, b) {
+  const pa = a.split(".");
+  const pb = b.split(".");
+  const n = Math.max(pa.length, pb.length);
+  for (let i = 0; i < n; i++) {
+    const sa = pa[i] ?? "0";
+    const sb = pb[i] ?? "0";
+    const na = Number.parseInt(sa, 10);
+    const nb = Number.parseInt(sb, 10);
+    if (Number.isNaN(na) || Number.isNaN(nb)) {
+      const c = sa.localeCompare(sb);
+      if (c !== 0) return c;
+    } else if (na !== nb) {
+      return na - nb;
+    }
+  }
+  return 0;
+}
 var AdminApiClient = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
@@ -712,6 +731,57 @@ var AdminApiClient = class {
   async installApplication(request) {
     return unwrap(await this.httpClient.post("/admin-api/install-application", request));
   }
+  /**
+   * Resolve a `package@version` to its registry artifact URL and install it.
+   * Node install is URL-based (no node-side package+version resolution), so this
+   * fetches the bundle manifest from the registry, derives the `.mpk` artifact
+   * URL, then calls {@link installApplication}. `registryUrl` is the registry
+   * origin. This is the discrete "download" step an Updates flow pairs with a
+   * subsequent `upgradeGroup`.
+   */
+  async installFromRegistry(registryUrl, packageName, version) {
+    const base = new URL(registryUrl).origin;
+    const manifestUrl = new URL(
+      `/api/v2/bundles/${encodeURIComponent(packageName)}/${encodeURIComponent(version)}`,
+      base
+    ).toString();
+    const resp = await fetch(manifestUrl);
+    if (!resp.ok) {
+      throw new Error(
+        `registry manifest fetch failed (${resp.status}) for ${packageName}@${version}`
+      );
+    }
+    const bundle = await resp.json();
+    const pkg = encodeURIComponent(bundle.package);
+    const ver = encodeURIComponent(bundle.appVersion);
+    const artifactUrl = `${base}/artifacts/${pkg}/${ver}/${pkg}-${ver}.mpk`;
+    return this.installApplication({
+      url: artifactUrl,
+      package: bundle.package,
+      version: bundle.appVersion,
+      metadata: []
+    });
+  }
+  /**
+   * List a package's published versions from the registry, newest-first by
+   * semver. Reads the registry's V2 bundle listing
+   * (`GET {registry}/api/v2/bundles?package={package}`), taking each bundle's
+   * `appVersion`. Registry-side data — distinct from the node's
+   * installed-version list — and the source an Updates view compares against
+   * the running `Context.applicationVersion` to detect "a new version exists".
+   */
+  async getRegistryVersions(registryUrl, packageName) {
+    const url = new URL("/api/v2/bundles", new URL(registryUrl).origin);
+    url.searchParams.set("package", packageName);
+    const resp = await fetch(url.toString());
+    if (!resp.ok) {
+      throw new Error(
+        `registry versions fetch failed (${resp.status}) for ${packageName}`
+      );
+    }
+    const bundles = await resp.json();
+    return (Array.isArray(bundles) ? bundles : []).map((b) => b.appVersion).filter((v) => typeof v === "string").sort((a, b) => compareSemver(b, a));
+  }
   async installDevApplication(request) {
     return unwrap(await this.httpClient.post("/admin-api/install-dev-application", request));
   }
@@ -1064,6 +1134,22 @@ var AdminApiClient = class {
       await this.httpClient.get(`/admin-api/groups/${groupId}/upgrade/status`)
     );
   }
+  /**
+   * The operator-facing "have all peers migrated?" rollup for a namespace.
+   * The handler serializes the payload directly, so there is no `{ data }`
+   * envelope to unwrap here (unlike most admin reads).
+   */
+  async getMigrationStatus(namespaceId) {
+    const id = encodeURIComponent(namespaceId);
+    return this.httpClient.get(`/admin-api/groups/${id}/migration-status`);
+  }
+  /** Per-group cascade-migration snapshots for a namespace. */
+  async getCascadeStatus(namespaceId) {
+    const id = encodeURIComponent(namespaceId);
+    return unwrap(
+      await this.httpClient.get(`/admin-api/groups/${id}/cascade-status`)
+    );
+  }
   async retryGroupUpgrade(groupId, request) {
     return unwrap(
       await this.httpClient.post(
@@ -1262,6 +1348,19 @@ var RpcClient = class {
     }
     return response.result;
   }
+  /**
+   * One-tap owner-driven convert: re-signs the caller's identity-gated entries
+   * to the current schema. The export converts all of the caller's
+   * below-target entries in a single sweep, so this issues one call and returns
+   * the resulting summary — it does not loop.
+   */
+  async migrateMyEntries(contextId) {
+    return this.execute({ contextId, method: "migrate_my_entries" });
+  }
+  /** Read-only count of the caller's entries still below the target schema. */
+  async countMyPending(contextId) {
+    return this.execute({ contextId, method: "count_my_pending" });
+  }
 };
 
 // src/events/sse.ts
@@ -1292,6 +1391,20 @@ var SseClient = class {
       if (idx !== -1) arr.splice(idx, 1);
     }
   }
+  /**
+   * Typed convenience over the generic `'event'` stream: invokes `handler` only
+   * for `AppVersionChanged` context events, with the payload already parsed.
+   * Returns an unsubscribe closure (so callers need not retain the listener).
+   */
+  onAppVersionChanged(handler) {
+    const listener = (ev) => {
+      const d = ev.data;
+      if (d?.type !== "AppVersionChanged") return;
+      handler({ contextId: ev.contextId, fromVersion: d.data?.fromVersion, toVersion: d.data?.toVersion });
+    };
+    this.on("event", listener);
+    return () => this.off("event", listener);
+  }
   emit(event, arg) {
     const key = event;
     if (key in this.listeners) {