@gravity-rail/sdk 0.18.1 → 0.21.0

package/dist/index.js

@@ -72,7 +72,6 @@ import {
   REALTIME_MODEL_CUSTOM,
   REALTIME_MODEL_GEMINI,
   REALTIME_MODEL_GEMINI_VERTEX,
-  REALTIME_MODEL_NOVA_SONIC,
   REALTIME_MODEL_OPENAI,
   REALTIME_MODEL_OPENAI_2,
   REALTIME_MODEL_OPENAI_MINI,
@@ -143,7 +142,7 @@ import {
   roleWorkflowAccess,
   usesBuiltinAssistant,
   validateFeatureDependencies
-} from "./chunk-PUIYXJSZ.js";
+} from "./chunk-24L4RD4Z.js";
 import {
   AttendeeResponseStatus,
   AttendeeStatus,
@@ -158,13 +157,13 @@ import {
   DataSensitivity,
   DataTypeRecordScope,
   IndexStatus
-} from "./chunk-2YLKG4TT.js";
+} from "./chunk-3HAV5XUJ.js";
 import {
   ApiError,
   BaseApiClient,
   getCookieValue,
   parseOrgAuthChallenge
-} from "./chunk-PJFEGUHM.js";
+} from "./chunk-7OLBLLV7.js";
 
 // src/workspace-builder/resource.ts
 function isRecord(value) {
@@ -315,6 +314,7 @@ var RoutineBuilder = class extends WorkspaceBuilderResource {
     return `Routine: ${this.name} (${parts.join(", ")})`;
   }
   async apply(client) {
+    if (this._existed) return;
     const eventRules = this.rules.map((rule) => {
       const actionParams = { ...rule.actionParams };
       if (rule.workflow?._id !== void 0) actionParams.workflowId = rule.workflow._id;
@@ -370,6 +370,7 @@ var NotificationRuleBuilder = class extends WorkspaceBuilderResource {
     return `NotificationRule: ${this.name}${parts.length ? ` (${parts.join(", ")})` : ""}`;
   }
   async apply(client) {
+    if (this._existed) return;
     if (this.memberId === void 0) {
       throw new Error(`Notification rule '${this.name}' requires memberId`);
     }
@@ -904,6 +905,7 @@ var RoleUpdate = class extends WorkspaceBuilderResource {
     return `RoleUpdate: roleId=${this.roleId}${parts.length ? ` (${parts.join(", ")})` : ""}`;
   }
   async apply(client) {
+    if (this._existed) return;
     const payload = {};
     if (this.workflowIds) payload.workflowIds = this.workflowIds;
     if (this.dataTypeIds) payload.dataTypeIds = this.dataTypeIds;
@@ -1133,6 +1135,7 @@ var AgentBuilder = class extends WorkspaceBuilderResource {
     return `Agent: ${this.name}${parts.length ? ` (${parts.join(", ")})` : ""}`;
   }
   async apply(client) {
+    if (this._existed) return;
     if (this.memberRoleId === void 0) {
       throw new Error(`Agent '${this.name}' requires memberRoleId`);
     }
@@ -1168,6 +1171,25 @@ var PHASES = /* @__PURE__ */ new Map([
   [JourneyBuilder, 7],
   [JourneyStepBuilder, 8]
 ]);
+var LIST_PAGE_SIZE = 100;
+async function collectPages(fetchPage) {
+  const first = await fetchPage(1);
+  const all = [...first.items];
+  const totalPages = first.totalPages ?? 1;
+  for (let page = 2; page <= totalPages; page++) {
+    const next = await fetchPage(page);
+    if (!next.items.length) break;
+    all.push(...next.items);
+  }
+  return all;
+}
+function sameIdSet(left, right) {
+  const target = new Set(right);
+  return target.size === new Set(left).size && left.every((id) => target.has(id));
+}
+function notificationRuleKey(noticeType, memberId, workflowId) {
+  return JSON.stringify([noticeType, memberId, workflowId]);
+}
 function phaseFor(resource) {
   let ctor = resource.constructor;
   while (ctor) {
@@ -1430,6 +1452,103 @@ Done! Created ${count} resources.`);
         journeyNames.get(existing.name).adopt(detail);
       }
     }
+    const agentNames = new Map(
+      resources.filter((resource) => resource instanceof AgentBuilder).map((resource) => [resource.name, resource])
+    );
+    if (agentNames.size) {
+      for (const existing of await collectPages(
+        (page) => this.client.getAgents({ page, pageSize: LIST_PAGE_SIZE })
+      )) {
+        if (existing.name && agentNames.has(existing.name)) {
+          agentNames.get(existing.name).adopt(existing);
+        }
+      }
+    }
+    const routineNames = new Map(
+      resources.filter((resource) => resource instanceof RoutineBuilder).map((resource) => [resource.name, resource])
+    );
+    if (routineNames.size) {
+      for (const existing of await collectPages(
+        (page) => this.client.getRoutines({ page, pageSize: LIST_PAGE_SIZE })
+      )) {
+        if (existing.name && routineNames.has(existing.name)) {
+          routineNames.get(existing.name).adopt(existing);
+        }
+      }
+    }
+    await this.resolveExistingRoleUpdates(resources);
+    await this.resolveExistingWorkflows(resources, workflowNames);
+    await this.resolveExistingNotificationRules(resources);
+  }
+  /**
+   * Adopt a role update whose grants the server already has.
+   *
+   * A role update is a replace-semantics PUT, not a create, so its identity is
+   * the role id and "already applied" means the id sets match exactly. Subset
+   * would be wrong: `roleUpdate(7, [])` asks to *clear* the role's workflow
+   * access, and treating that as satisfied by a role that still has grants
+   * would silently skip a real change.
+   *
+   * Only the fields this update declares are compared — an update that passes
+   * `workflowIds` and omits `dataTypeIds` never touches data-type access, so
+   * that access cannot make it stale.
+   */
+  async resolveExistingRoleUpdates(resources) {
+    const updates = resources.filter(
+      (resource) => resource instanceof RoleUpdate
+    );
+    if (!updates.length) return;
+    const rolesById = new Map(
+      (await this.client.getMemberRoles()).map((role) => [role.id, role])
+    );
+    for (const update of updates) {
+      const role = rolesById.get(update.roleId);
+      if (!role) continue;
+      const workflowsSettled = update.workflowIds === void 0 || sameIdSet(
+        update.workflowIds,
+        (role.workflowAccess ?? []).map((access) => access.workflowId)
+      );
+      const dataTypesSettled = update.dataTypeIds === void 0 || sameIdSet(
+        update.dataTypeIds,
+        (role.dataTypeAccess ?? []).map((access) => access.dataTypeId)
+      );
+      if (workflowsSettled && dataTypesSettled) update.adopt(role);
+    }
+  }
+  /**
+   * Adopt notification rules the server already has.
+   *
+   * There is no name on the server row — `NotificationRule` is keyed by what
+   * it does — so identity is the composite the API enforces uniqueness on in
+   * practice: notice type, recipient, and subject workflow.
+   */
+  async resolveExistingNotificationRules(resources) {
+    const rules = resources.filter(
+      (resource) => resource instanceof NotificationRuleBuilder
+    );
+    if (!rules.length) return;
+    const identified = rules.flatMap((rule) => {
+      if (rule.memberId === void 0) return [];
+      if (rule.workflow && rule.workflow._id === void 0) return [];
+      return [
+        [
+          notificationRuleKey(rule.noticeType, rule.memberId, rule.workflow?._id ?? null),
+          rule
+        ]
+      ];
+    });
+    if (!identified.length) return;
+    const byKey = new Map(identified);
+    for (const existing of await this.client.getNotificationRules()) {
+      const key = notificationRuleKey(
+        existing.noticeType,
+        existing.memberId,
+        existing.workflowId ?? null
+      );
+      byKey.get(key)?.adopt(existing);
+    }
+  }
+  async resolveExistingWorkflows(resources, workflowNames) {
     if (!workflowNames.size) return;
     const existingWorkflows = await this.client.getWorkflows();
     for (const { workflow: existing } of existingWorkflows.items) {
@@ -1949,7 +2068,6 @@ export {
   REALTIME_MODEL_CUSTOM,
   REALTIME_MODEL_GEMINI,
   REALTIME_MODEL_GEMINI_VERTEX,
-  REALTIME_MODEL_NOVA_SONIC,
   REALTIME_MODEL_OPENAI,
   REALTIME_MODEL_OPENAI_2,
   REALTIME_MODEL_OPENAI_MINI,