exponential-sdk 1.10.0 → 1.12.0

package/dist/index.js

@@ -169,6 +169,271 @@ var ActionCommentsApi = class {
   }
 };
 
+// src/featureComments.ts
+var FeatureCommentsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(featureId) {
+    return await this.client.product.featureComment.list.query({
+      featureId
+    });
+  }
+  async create(input) {
+    return await this.client.product.featureComment.create.mutate(
+      input
+    );
+  }
+  /** Reply to an existing comment. Replies to replies still hang off the root. */
+  async reply(input) {
+    return await this.client.product.featureComment.reply.mutate(
+      input
+    );
+  }
+  async update(input) {
+    return await this.client.product.featureComment.update.mutate(
+      input
+    );
+  }
+  async delete(commentId) {
+    return await this.client.product.featureComment.delete.mutate({
+      commentId
+    });
+  }
+  /** Mark an anchored thread resolved. Only anchored threads have a threadId. */
+  async resolve(input) {
+    return await this.client.product.featureComment.resolve.mutate(
+      input
+    );
+  }
+  async unresolve(input) {
+    return await this.client.product.featureComment.unresolve.mutate(
+      input
+    );
+  }
+};
+
+// src/pageComments.ts
+var PageCommentsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(pageId) {
+    return await this.client.pageComment.list.query({ pageId });
+  }
+  async create(input) {
+    return await this.client.pageComment.create.mutate(input);
+  }
+  async update(input) {
+    return await this.client.pageComment.update.mutate(input);
+  }
+  async delete(commentId) {
+    return await this.client.pageComment.delete.mutate({
+      commentId
+    });
+  }
+};
+
+// src/goalComments.ts
+var GoalCommentsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(goalId) {
+    return await this.client.goalComment.getComments.query({
+      goalId
+    });
+  }
+  async add(input) {
+    return await this.client.goalComment.addComment.mutate(input);
+  }
+  async update(input) {
+    return await this.client.goalComment.updateComment.mutate(
+      input
+    );
+  }
+  async delete(commentId) {
+    return await this.client.goalComment.deleteComment.mutate({
+      commentId
+    });
+  }
+};
+
+// src/goals.ts
+var GoalsApi = class {
+  constructor(client, keyResults) {
+    this.client = client;
+    this.keyResults = keyResults;
+  }
+  /**
+   * List objectives. Pass `workspaceId` for the workspace-wide list (every
+   * member's), omit it for your own. Includes each objective's linked
+   * `projects`, which is the join that maps day-to-day work back to an OKR:
+   * every action carries a `projectId`.
+   *
+   * `period` and `status` are sent to the server *and* re-applied here. The
+   * server grew those filters recently; against an instance that predates them
+   * zod strips the unknown keys and hands back **every** objective — a filter
+   * that silently matches everything is worse than one that errors. Re-applying
+   * is a no-op once the server has done the work. Same reasoning as the
+   * client-side `branchName`/`prUrl` filters in `tickets.ts`.
+   */
+  async list(options = {}) {
+    const goals = await this.client.goal.getAllMyGoals.query(options);
+    return goals.filter(
+      (g) => (options.period === void 0 || g.period === options.period) && (options.status === void 0 || g.status === options.status)
+    );
+  }
+  /**
+   * The same objectives nested parent → child (up to 5 levels), each with its
+   * projects and key results. One call for the whole annual → quarterly cascade.
+   */
+  async tree(options = {}) {
+    return await this.client.goal.getGoalTree.query(
+      options
+    );
+  }
+  async get(id) {
+    return await this.client.goal.getById.query({ id });
+  }
+  /** Objectives linked to a given project. */
+  async listByProject(projectId) {
+    return await this.client.goal.getProjectGoals.query({ projectId });
+  }
+  async create(input) {
+    return await this.client.goal.createGoal.mutate(input);
+  }
+  /**
+   * Partial update — see {@link GoalUpdateInput}. Fields you omit are left
+   * alone; pass an explicit `null` to clear one.
+   */
+  async update(input) {
+    return await this.client.goal.updateGoal.mutate(input);
+  }
+  /**
+   * Status-only write. Never touches another field, and is the only path that
+   * accepts `on-hold`. Moving an objective to `completed` also records a
+   * workspace milestone.
+   */
+  async setStatus(input) {
+    return await this.client.goal.updateGoalStatus.mutate(input);
+  }
+  /**
+   * Re-parent an objective, or detach it with `parentGoalId: null`. Writes only
+   * `parentGoalId`, and validates the no-self / no-cycle / depth-5 rules.
+   */
+  async setParent(input) {
+    return await this.client.goal.setParent.mutate(input);
+  }
+  async delete(id) {
+    return await this.client.goal.deleteGoal.mutate({ id });
+  }
+  /** The conventional period strings (quarters, halves, annual) for this year and next. */
+  async periods() {
+    return await this.client.okr.getPeriods.query();
+  }
+  /** Aggregate objective/key-result counts and average progress. */
+  async stats(options = {}) {
+    return await this.client.okr.getStats.query(options);
+  }
+};
+
+// src/keyResults.ts
+var KeyResultsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List key results. Pass `workspaceId` for the workspace-wide list (every
+   * member's), omit it for your own.
+   *
+   * ⚠️ Workspace scoping here depends on a server-side fix to `okr.getAll`,
+   * which previously accepted a `workspaceId` while still filtering on the
+   * caller's `userId` — so against an older instance this returns only your own
+   * key results, or `[]`, rather than the workspace's. Unlike the filters in
+   * `goals.list()` that cannot be repaired here: the other members' rows never
+   * reach the client. {@link KeyResultsApi.byObjective} is workspace-correct on
+   * every server version and is the safer read when that matters.
+   */
+  async list(options = {}) {
+    return await this.client.okr.getAll.query(options);
+  }
+  /**
+   * Objectives with their key results nested — the richest OKR read, and the
+   * one to reach for when rendering "here is the quarter".
+   */
+  async byObjective(options = {}) {
+    return await this.client.okr.getByObjective.query(
+      options
+    );
+  }
+  async get(id) {
+    return await this.client.okr.getById.query({ id });
+  }
+  /**
+   * Create a key result on an objective.
+   *
+   * When `workspaceId` is omitted it is resolved from the objective first,
+   * rather than left to the server. `okr.create` writes the input through as-is
+   * on older instances, so an absent workspace persists as `null` — and a key
+   * result with no workspace is invisible to every workspace-scoped read and
+   * unwritable by teammates once owner-OR-member authz applies. That is the
+   * same orphaning that has already cost a goal; one extra read on a mutation
+   * is a cheap way not to repeat it.
+   */
+  async create(input) {
+    let workspaceId = input.workspaceId;
+    if (workspaceId === void 0) {
+      const goal = await this.client.goal.getById.query({
+        id: input.goalId
+      });
+      workspaceId = goal.workspaceId ?? void 0;
+    }
+    return await this.client.okr.create.mutate({
+      ...input,
+      workspaceId
+    });
+  }
+  async update(input) {
+    return await this.client.okr.update.mutate(input);
+  }
+  /**
+   * Record a progress check-in. The server derives the new status from where
+   * `value` lands between `startValue` and `targetValue`, so a check-in both
+   * moves the number and re-colours the key result.
+   */
+  async checkIn(input) {
+    return await this.client.okr.checkIn.mutate({
+      keyResultId: input.id,
+      newValue: input.value,
+      notes: input.note
+    });
+  }
+  async delete(id) {
+    return await this.client.okr.delete.mutate({ id });
+  }
+  /** Link a project to a key result as executing work. Idempotent. */
+  async linkProject(input) {
+    return await this.client.okr.linkProject.mutate(input);
+  }
+  async unlinkProject(input) {
+    return await this.client.okr.unlinkProject.mutate(input);
+  }
+  /**
+   * Link a feature to a key result as executing work. Idempotent. The feature's
+   * product must live in the key result's workspace. A feature with no
+   * objective alignment inherits the key result's objective; one that already
+   * has an objective is never overwritten.
+   */
+  async linkFeature(input) {
+    return await this.client.okr.linkFeature.mutate(input);
+  }
+  /** Removes only the link row — never the feature's objective alignment. */
+  async unlinkFeature(input) {
+    return await this.client.okr.unlinkFeature.mutate(input);
+  }
+};
+
 // src/projects.ts
 var ProjectsApi = class {
   constructor(client) {
@@ -191,6 +456,17 @@ var WorkspacesApi = class {
   async list() {
     return await this.client.workspace.list.query();
   }
+  /**
+   * Everyone who belongs to a workspace — direct members plus anyone with
+   * access through a linked team. This is the lookup that makes mentions
+   * possible from outside the app: match a name or email here, then drop the
+   * row's `mentionSyntax` into a comment body.
+   */
+  async listMembers(workspaceId) {
+    return await this.client.workspace.listMembers.query({
+      workspaceId
+    });
+  }
 };
 
 // src/contacts.ts
@@ -323,6 +599,11 @@ var TicketsApi = class {
       input
     );
   }
+  async updateComment(input) {
+    return await this.client.product.ticket.updateComment.mutate(
+      input
+    );
+  }
   async deleteComment(id) {
     return await this.client.product.ticket.deleteComment.mutate({
       id
@@ -693,6 +974,11 @@ var ExponentialClient = class {
     this.client = createClient(this.config);
     this.actions = new ActionsApi(this.client);
     this.actionComments = new ActionCommentsApi(this.client);
+    this.featureComments = new FeatureCommentsApi(this.client);
+    this.pageComments = new PageCommentsApi(this.client);
+    this.goalComments = new GoalCommentsApi(this.client);
+    this.keyResults = new KeyResultsApi(this.client);
+    this.goals = new GoalsApi(this.client, this.keyResults);
     this.projects = new ProjectsApi(this.client);
     this.workspaces = new WorkspacesApi(this.client);
     this.contacts = new ContactsApi(this.client);
@@ -713,6 +999,12 @@ var ExponentialClient = class {
   client;
   actions;
   actionComments;
+  featureComments;
+  pageComments;
+  goalComments;
+  goals;
+  /** Same instance as `goals.keyResults`. */
+  keyResults;
   projects;
   workspaces;
   contacts;