exponential-sdk 1.11.0 → 1.12.0

package/dist/index.js

@@ -259,6 +259,181 @@ var GoalCommentsApi = class {
   }
 };
 
+// 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) {
@@ -802,6 +977,8 @@ var ExponentialClient = class {
     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);
@@ -825,6 +1002,9 @@ var ExponentialClient = class {
   featureComments;
   pageComments;
   goalComments;
+  goals;
+  /** Same instance as `goals.keyResults`. */
+  keyResults;
   projects;
   workspaces;
   contacts;