@granular-software/sdk 0.4.51 → 0.4.53

package/dist/index.mjs

@@ -14287,7 +14287,8 @@ function normalizeEnvironmentSetupSummary(setup) {
     environmentId: String(setup.environmentId || ""),
     sandboxId: String(setup.sandboxId || ""),
     subjectId: String(setup.subjectId || ""),
-    triggerReason: setup.triggerReason === "fresh_after_version_update" ? "fresh_after_version_update" : "new_environment",
+    triggerReason: setup.triggerReason === "fresh_after_version_update" ? "fresh_after_version_update" : setup.triggerReason === "explicit_reset" ? "explicit_reset" : "new_environment",
+    operationKey: typeof setup.operationKey === "string" ? setup.operationKey : null,
     lifecycleStatus: setup.lifecycleStatus === "completed" || setup.lifecycleStatus === "failed" ? setup.lifecycleStatus : "running",
     stage: typeof setup.stage === "string" ? setup.stage : null,
     totalObjectsToImport: Number(setup.totalObjectsToImport || 0),
@@ -15569,6 +15570,7 @@ var Environment = class _Environment {
           records: recordsToImport,
           batchSize: options.batchSize,
           setupRunId: options.setupRunId,
+          operationKey: options.operationKey,
           writeMode: options.writeMode
         })
       }
@@ -16373,6 +16375,156 @@ var Granular = class _Granular {
     await this.maybeRunEnvironmentImporter(resolved, environment);
     return environment;
   }
+  /**
+   * Read the active environment selected by Granular for an already-recorded
+   * external user. This is intentionally read-only: browser/login code must
+   * not create subjects or environments as a side effect.
+   */
+  async getActiveEnvironmentForUser(options) {
+    const sandboxId = options.sandboxId.trim();
+    const tagName = options.tag.trim();
+    const userId = options.userId.trim();
+    if (!sandboxId || !tagName || !userId) {
+      throw new Error(
+        "getActiveEnvironmentForUser() requires sandboxId, tag, and userId."
+      );
+    }
+    const subjects = await this.request(
+      `/control/subjects?identityId=${encodeURIComponent(userId)}`
+    );
+    const subject = (subjects.items || []).find(
+      (item) => item.identityId === userId || item.userId === userId
+    );
+    if (!subject?.subjectId && !subject?.granularId) {
+      return null;
+    }
+    const subjectId = subject.subjectId || subject.granularId;
+    const tags = await this.request(
+      `/control/sandboxes/${encodeURIComponent(sandboxId)}/tags`
+    );
+    const tag = (tags.items || []).find(
+      (item) => item?.name === tagName
+    );
+    if (!tag) return null;
+    const query = new URLSearchParams({
+      tagId: tag.tagId,
+      slot: options.slot?.trim() || "default"
+    });
+    try {
+      const payload = await this.request(
+        `/control/sandboxes/${encodeURIComponent(sandboxId)}/subjects/${encodeURIComponent(subjectId)}/active-environment?${query.toString()}`
+      );
+      return payload.environment ? this.bindEnvironmentHandle(
+        normalizeEnvironmentData(payload.environment)
+      ) : null;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("404") || message.includes("not found")) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Resolve one exact environment only when Granular confirms that it belongs
+   * to the given external user in the requested sandbox (and, optionally,
+   * tag). This is deliberately read-only: callers use it to keep an already
+   * opened delegated workspace stable while a newer active environment is
+   * being prepared in the background.
+   */
+  async getEnvironmentForUser(options) {
+    const sandboxId = options.sandboxId.trim();
+    const userId = options.userId.trim();
+    const environmentId = options.environmentId.trim();
+    const tagName = options.tag?.trim();
+    if (!sandboxId || !userId || !environmentId) {
+      throw new Error(
+        "getEnvironmentForUser() requires sandboxId, userId, and environmentId."
+      );
+    }
+    const subjects = await this.request(
+      `/control/subjects?identityId=${encodeURIComponent(userId)}`
+    );
+    const subject = (subjects.items || []).find(
+      (item) => item.identityId === userId || item.userId === userId
+    );
+    const subjectId = subject?.subjectId || subject?.granularId;
+    if (!subjectId) return null;
+    let environment;
+    try {
+      environment = await this.environments.get(environmentId);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("404") || message.includes("not found")) {
+        return null;
+      }
+      throw error;
+    }
+    if (environment.sandboxId !== sandboxId || environment.subjectId !== subjectId) {
+      return null;
+    }
+    if (tagName) {
+      const tags = await this.request(`/control/sandboxes/${encodeURIComponent(sandboxId)}/tags`);
+      const tag = (tags.items || []).find(
+        (candidate) => candidate?.name === tagName
+      );
+      if (!tag || environment.tagId !== tag.tagId) {
+        return null;
+      }
+    }
+    return this.bindEnvironmentHandle(environment);
+  }
+  /**
+   * Register one reviewed, pre-existing environment as the active workspace
+   * for an external user. This is for a controlled migration only: it does
+   * not create an environment and it does not run an importer.
+   */
+  async adoptEnvironmentForUser(options) {
+    const sandboxId = options.sandboxId.trim();
+    const tagName = options.tag.trim();
+    const userId = options.userId.trim();
+    const environmentId = options.environmentId.trim();
+    if (!sandboxId || !tagName || !userId || !environmentId) {
+      throw new Error(
+        "adoptEnvironmentForUser() requires sandboxId, tag, userId, and environmentId."
+      );
+    }
+    const subjects = await this.request(
+      `/control/subjects?identityId=${encodeURIComponent(userId)}`
+    );
+    const subject = (subjects.items || []).find(
+      (item) => item.identityId === userId || item.userId === userId
+    );
+    if (!subject?.subjectId && !subject?.granularId) {
+      throw new Error(`No Granular subject exists for user ${userId}.`);
+    }
+    const tags = await this.request(`/control/sandboxes/${encodeURIComponent(sandboxId)}/tags`);
+    const tag = (tags.items || []).find(
+      (item) => item?.name === tagName
+    );
+    if (!tag) {
+      throw new Error(`Tag ${tagName} was not found in sandbox ${sandboxId}.`);
+    }
+    const payload = await this.request(
+      "/control/environment-activations/adopt",
+      {
+        method: "POST",
+        body: JSON.stringify({
+          environmentId,
+          subjectId: subject.subjectId || subject.granularId,
+          tagId: tag.tagId,
+          slot: options.slot?.trim() || "default",
+          confirmExistingData: true
+        })
+      }
+    );
+    if (!payload.environment) {
+      throw new Error("Granular did not return the adopted environment.");
+    }
+    return this.bindEnvironmentHandle(
+      normalizeEnvironmentData(payload.environment)
+    );
+  }
   /**
    * Deprecated compatibility alias for `openEnvironment()`.
    *
@@ -16404,7 +16556,9 @@ var Granular = class _Granular {
         requestedOntology,
         sandboxId: environmentData.sandboxId,
         subjectId: environmentData.subjectId,
-        setupTriggerReason: options.reason || "new_environment"
+        externalUserId: environmentData.subjectId,
+        setupTriggerReason: options.reason || "new_environment",
+        setupOperationKey: options.operationKey
       },
       environment
     );
@@ -16416,20 +16570,17 @@ var Granular = class _Granular {
     }
     return tag;
   }
-  buildManagedEnvironmentName(tag, versionId) {
-    return `__sdk__${tag}__${versionId}__pinned`;
+  buildManagedEnvironmentName(tag, versionId, resetKey) {
+    if (!resetKey) {
+      return `__sdk__${tag}__${versionId}__tracked`;
+    }
+    const safeResetKey = resetKey.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 80);
+    return `__sdk__${tag}__${versionId}__reset__${safeResetKey}`;
   }
   isManagedEnvironmentName(environment, tagName) {
     const name = environment.environment || environment.envName || "";
     return name.startsWith(`__sdk__${tagName}__`);
   }
-  isPinnedToVersion(environment, versionId) {
-    return environment.buildPolicy.mode === "pinned" && (environment.versionId === versionId || environment.buildPolicy.versionId === versionId || environment.buildPolicy.buildId === versionId);
-  }
-  matchesTagTrackedEnvironment(environment, tagName, tagId) {
-    const environmentTagName = environment.tag?.name || environment.buildPolicy.tagName || null;
-    return environment.tagId === tagId || environmentTagName === tagName || environment.environment === tagName || environment.envName === tagName || environment.environment === this.buildManagedEnvironmentName(tagName, environment.versionId) || environment.envName === this.buildManagedEnvironmentName(tagName, environment.versionId);
-  }
   sortEnvironmentsByRecency(environments) {
     return [...environments].sort(
       (left, right) => right.updatedAt - left.updatedAt
@@ -16479,48 +16630,119 @@ var Granular = class _Granular {
         `Tag "${tagName}" does not currently point to a build/version.`
       );
     }
+    const slot = options.slot?.trim() || "default";
+    const resetKey = options.resetKey?.trim() || void 0;
+    const resolveActive = async (operationKey) => {
+      const query = new URLSearchParams({ tagId: tag.tagId, slot });
+      if (operationKey) query.set("operationKey", operationKey);
+      try {
+        const payload = await this.request(
+          `/control/sandboxes/${encodeURIComponent(sandbox.sandboxId)}/subjects/${encodeURIComponent(user.granularId)}/active-environment?${query.toString()}`
+        );
+        return payload.environment ? normalizeEnvironmentData(payload.environment) : null;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("404") || message.includes("not found")) {
+          return null;
+        }
+        throw error;
+      }
+    };
+    const activate = async (environment2) => {
+      const payload = await this.request(
+        "/control/environment-activations",
+        {
+          method: "POST",
+          body: JSON.stringify({
+            environmentId: environment2.environmentId,
+            tagId: tag.tagId,
+            slot,
+            operationKey: resetKey,
+            operation: resetKey ? "explicit_reset" : void 0
+          })
+        }
+      );
+      return normalizeEnvironmentData(payload.environment);
+    };
+    if (resetKey) {
+      const resetEnvironment = await resolveActive(resetKey);
+      if (resetEnvironment) {
+        return {
+          environment: resetEnvironment,
+          requestedOntology: ontology,
+          sandboxId: sandbox.sandboxId,
+          subjectId: user.granularId,
+          externalUserId: user.userId,
+          // Retrying an explicit reset must also resume its durable setup run.
+          // Otherwise a Container crash after queue submission would leave a
+          // valid environment permanently marked as "running".
+          setupTriggerReason: "explicit_reset",
+          setupOperationKey: resetKey
+        };
+      }
+    } else {
+      const active = await resolveActive();
+      if (active && (active.versionId === targetVersionId || options.createFreshIfOutdated !== true)) {
+        return {
+          environment: active,
+          requestedOntology: ontology,
+          sandboxId: sandbox.sandboxId,
+          subjectId: user.granularId,
+          externalUserId: user.userId
+        };
+      }
+    }
     const allEnvironments = await this.environments.list(sandbox.sandboxId);
     const userEnvironments = allEnvironments.filter(
-      (environment) => environment.subjectId === user.granularId
+      (environment2) => environment2.subjectId === user.granularId
     );
     const currentMatches = this.sortEnvironmentsByRecency(
       userEnvironments.filter(
-        (environment) => this.matchesTagTrackedEnvironment(environment, tagName, tag.tagId) && environment.versionId === targetVersionId && (!this.isManagedEnvironmentName(environment, tagName) || this.isPinnedToVersion(environment, targetVersionId))
+        (environment2) => environment2.tagId === tag.tagId && environment2.versionId === targetVersionId
       )
     );
-    if (currentMatches.length > 0) {
+    if (!resetKey && currentMatches.length > 0) {
+      const environment2 = await activate(currentMatches[0]);
       return {
-        environment: currentMatches[0],
+        environment: environment2,
         requestedOntology: ontology,
         sandboxId: sandbox.sandboxId,
-        subjectId: user.granularId
+        subjectId: user.granularId,
+        externalUserId: user.userId
       };
     }
     const outdatedMatches = this.sortEnvironmentsByRecency(
-      userEnvironments.filter(
-        (environment) => this.matchesTagTrackedEnvironment(environment, tagName, tag.tagId)
-      )
+      userEnvironments.filter((environment2) => environment2.tagId === tag.tagId)
     );
     if (outdatedMatches.length > 0 && options.createFreshIfOutdated !== true) {
+      const environment2 = await activate(outdatedMatches[0]);
       return {
-        environment: outdatedMatches[0],
+        environment: environment2,
         requestedOntology: ontology,
         sandboxId: sandbox.sandboxId,
-        subjectId: user.granularId
+        subjectId: user.granularId,
+        externalUserId: user.userId
       };
     }
+    const created = await this.environments.create(sandbox.sandboxId, {
+      subjectId: user.granularId,
+      environment: this.buildManagedEnvironmentName(
+        tagName,
+        targetVersionId,
+        resetKey
+      ),
+      tagId: tag.tagId,
+      permissionProfileId: null
+    });
+    const environment = await activate(created);
     return {
-      environment: await this.environments.create(sandbox.sandboxId, {
-        subjectId: user.granularId,
-        environment: this.buildManagedEnvironmentName(tagName, targetVersionId),
-        tagId: tag.tagId,
-        versionId: targetVersionId,
-        permissionProfileId: null
-      }),
+      environment,
       requestedOntology: ontology,
       sandboxId: sandbox.sandboxId,
       subjectId: user.granularId,
-      setupTriggerReason: outdatedMatches.length > 0 ? "fresh_after_version_update" : "new_environment"
+      externalUserId: user.userId,
+      setupTriggerReason: resetKey ? "explicit_reset" : outdatedMatches.length > 0 ? "fresh_after_version_update" : "new_environment",
+      setupOperationKey: resetKey
     };
   }
   /**
@@ -16799,11 +17021,24 @@ var Granular = class _Granular {
       {
         method: "POST",
         body: JSON.stringify({
-          triggerReason: resolved.setupTriggerReason
+          triggerReason: resolved.setupTriggerReason,
+          operationKey: resolved.setupOperationKey
         })
       }
     );
     const setupRunId = setupRun.setupRunId;
+    let claim = null;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      claim = await this.request(
+        `/control/environment-setup-runs/${setupRunId}/importer-claim`,
+        { method: "POST", body: JSON.stringify({}) }
+      );
+      if (claim.action !== "busy") break;
+      await sleep(Math.min(3e4, Math.max(250, claim.retryAfterMs || 1e3)));
+    }
+    if (!claim) {
+      throw new Error(`Unable to claim environment setup run ${setupRunId}.`);
+    }
     const updateSetupRun = async (patch) => {
       await this.request(
         `/control/environment-setup-runs/${setupRunId}`,
@@ -16813,10 +17048,26 @@ var Granular = class _Granular {
         }
       );
     };
+    if (claim.action === "submitted") {
+      const completedSetupRun = await this.request(
+        `/control/environment-setup-runs/${setupRunId}`,
+        { method: "PATCH", body: JSON.stringify({ markHookCompleted: true }) }
+      );
+      const refreshedEnvironment = await this.environments.get(
+        environment.environmentId
+      );
+      environment.syncEnvironmentData(refreshedEnvironment);
+      return completedSetupRun;
+    }
+    if (claim.action === "busy" || claim.action === "terminal") {
+      return claim.summary;
+    }
+    let importSequence = 0;
     const importerContext = {
       environmentId: environment.environmentId,
       sandboxId: environment.sandboxId,
       subjectId: environment.subjectId,
+      externalUserId: resolved.externalUserId,
       reason: resolved.setupTriggerReason,
       incrementTotalObjectsToImportCount: async (n) => {
         const safeIncrement = Math.max(0, Math.trunc(n));
@@ -16833,7 +17084,10 @@ var Granular = class _Granular {
       importRecords: async (records, options) => environment.enqueueRecordImport(records, {
         batchSize: options?.batchSize,
         writeMode: options?.writeMode,
-        setupRunId
+        setupRunId,
+        // Sequence is deterministic for a retry of one importer hook. It
+        // prevents a Container restart from creating a second queue import.
+        operationKey: `${setupRunId}:import:${importSequence++}`
       })
     };
     try {