@boboddy/sdk 0.1.38-alpha → 0.1.39-alpha

package/dist/push/index.js

@@ -12936,6 +12936,16 @@ class Projects extends HeyApiClient {
   getProject(options) {
     return (options.client ?? this.client).get({ url: "/api/projects/{projectId}", ...options });
   }
+  updateProjectDefaultPipelineAssignment(options) {
+    return (options.client ?? this.client).put({
+      url: "/api/projects/{projectId}/default-pipeline-assignment",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
   updateProjectMemberPermissions(options) {
     return (options.client ?? this.client).put({ url: "/api/projects/{projectId}/members/{userId}/permissions", ...options });
   }
@@ -16416,8 +16426,143 @@ var buildPipelineDefinitionsClient = (pipelineDefinitions) => {
     }
   };
 };
+// src/definitions/pipelines/define-default-pipeline-assignment.ts
+var DEFAULT_PIPELINE_ASSIGNMENT_FILENAME = "default-pipeline-assignment.ts";
+function makeLeaf(fact, path, operator, value) {
+  const condition = {
+    _tag: "leaf",
+    fact,
+    ...path ? { path } : {},
+    operator,
+    value
+  };
+  return {
+    _condition: condition,
+    then(outcome) {
+      return { _tag: "assignment_rule", conditions: [condition], mode: "all", outcome };
+    }
+  };
+}
+function makeFieldRef(fact, path) {
+  return {
+    eq: (v) => makeLeaf(fact, path, "equal", v),
+    ne: (v) => makeLeaf(fact, path, "notEqual", v),
+    gt: (v) => makeLeaf(fact, path, "greaterThan", v),
+    gte: (v) => makeLeaf(fact, path, "greaterThanInclusive", v),
+    lt: (v) => makeLeaf(fact, path, "lessThan", v),
+    lte: (v) => makeLeaf(fact, path, "lessThanInclusive", v),
+    in: (vs) => makeLeaf(fact, path, "in", vs),
+    notIn: (vs) => makeLeaf(fact, path, "notIn", vs),
+    contains: (v) => makeLeaf(fact, path, "contains", v),
+    doesNotContain: (v) => makeLeaf(fact, path, "doesNotContain", v)
+  };
+}
+function makeAssign(pipeline2) {
+  if (typeof pipeline2 !== "object" || pipeline2 === null || typeof pipeline2["key"] !== "string" || !Array.isArray(pipeline2["steps"])) {
+    throw new Error("assign() requires a pipeline spec produced by pipeline().build(). " + "Pass the default-exported value from a pipeline definition file.");
+  }
+  return { _tag: "assign", pipeline: pipeline2 };
+}
+function extractCondition2(ref) {
+  return ref._condition;
+}
+function makeGroup(mode, refs) {
+  const conditions = refs.map(extractCondition2);
+  const condition = { _tag: "group", mode, conditions };
+  return {
+    _condition: condition,
+    then(outcome) {
+      return { _tag: "assignment_rule", conditions, mode, outcome };
+    }
+  };
+}
+function buildCtx() {
+  return {
+    workItem: {
+      field: (name) => makeFieldRef("workItem", `$.fields.${name}`)
+    },
+    context: {
+      isNew: makeFieldRef("context", "$.isNew")
+    },
+    assign: makeAssign,
+    skip: () => ({ _tag: "skip" }),
+    all: (...refs) => makeGroup("all", refs),
+    any: (...refs) => makeGroup("any", refs)
+  };
+}
+function defaultPipelineAssignment(callback) {
+  const input = callback(buildCtx());
+  return {
+    _tag: "default_pipeline_assignment",
+    default: input.default,
+    rules: input.rules
+  };
+}
+function serializeConditionNode(condition) {
+  if (condition._tag === "leaf") {
+    return {
+      fact: condition.fact,
+      ...condition.path ? { path: condition.path } : {},
+      operator: condition.operator,
+      value: condition.value
+    };
+  }
+  if (condition._tag === "group") {
+    if (condition.mode === "all") {
+      return { all: condition.conditions.map(serializeConditionNode) };
+    }
+    return { any: condition.conditions.map(serializeConditionNode) };
+  }
+  throw new Error(`Unknown condition tag: ${JSON.stringify(condition["_tag"])}`);
+}
+function serializeOutcome(outcome) {
+  if (outcome._tag === "skip")
+    return { type: "skip", params: null };
+  return { type: "assign", params: { pipelineKey: outcome.pipeline.key } };
+}
+function serializeAssignmentRule(rule) {
+  const { type, params } = serializeOutcome(rule.outcome);
+  return {
+    conditions: { [rule.mode]: rule.conditions.map(serializeConditionNode) },
+    event: { type, ...params ? { params } : {} }
+  };
+}
+function serializeDefaultPipelineAssignment(spec) {
+  let primaryKey = null;
+  if (spec.default._tag === "assign") {
+    primaryKey = spec.default.pipeline.key;
+  } else {
+    for (const rule of spec.rules) {
+      if (rule.outcome._tag === "assign") {
+        primaryKey = rule.outcome.pipeline.key;
+        break;
+      }
+    }
+  }
+  if (primaryKey === null) {
+    throw new Error("defaultPipelineAssignment must contain at least one assign() outcome " + "(in `default` or in `rules`). A policy that only skips is not useful.");
+  }
+  const { type: defaultType, params: defaultParams } = serializeOutcome(spec.default);
+  const outcomeSet = new Set([defaultType]);
+  const serializedRules = spec.rules.map((rule) => {
+    outcomeSet.add(serializeOutcome(rule.outcome).type);
+    return serializeAssignmentRule(rule);
+  });
+  return {
+    linearPipelineDefinitionKey: primaryKey,
+    rulesJson: { rules: serializedRules },
+    defaultEventType: defaultType,
+    defaultEventParamsJson: defaultParams,
+    allowedEventTypes: [...outcomeSet]
+  };
+}
+function isDefaultPipelineAssignmentSpec(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  return value["_tag"] === "default_pipeline_assignment";
+}
 // src/push/push-from-directory.ts
-import { readdirSync } from "fs";
+import { existsSync, readdirSync } from "fs";
 import { join, resolve } from "path";
 import { pathToFileURL } from "url";
 function isStepDefinitionSpec(value) {
@@ -16449,7 +16594,9 @@ async function pushFromDirectory(dir, opts) {
   const log = opts.log ?? ((msg) => console.log(msg));
   const headers = { Authorization: `Bearer ${opts.accessToken}` };
   const absDir = resolve(dir);
-  const sourceFiles = readdirSync(absDir).filter((f) => (f.endsWith(".ts") || f.endsWith(".js")) && !PUSH_SCRIPT_NAMES.has(f));
+  const allFiles = readdirSync(absDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+  const hasAssignmentFile = existsSync(join(absDir, DEFAULT_PIPELINE_ASSIGNMENT_FILENAME));
+  const sourceFiles = allFiles.filter((f) => !PUSH_SCRIPT_NAMES.has(f) && f !== DEFAULT_PIPELINE_ASSIGNMENT_FILENAME);
   const pipelineSpecs = [];
   const stepMap = new Map;
   for (const file2 of sourceFiles) {
@@ -16481,40 +16628,119 @@ async function pushFromDirectory(dir, opts) {
     await stepsClient.upsertFromSpec(opts.projectId, spec, { headers });
     log(`\u2713 step ${spec.key} v${String(spec.version)} \u2192 upserted`);
   }
-  if (pipelineSpecs.length === 0) {
-    return { pushedSteps: stepMap.size, pushedPipelines: 0 };
-  }
   const pipelinesClient = createPipelineDefinitionsClient(opts.baseUrl);
-  const existingPipelines = await pipelinesClient.listByProjectId(opts.projectId, { headers });
-  const knownPipelineKeys = new Set([
-    ...pipelineSpecs.map((s) => s.key),
-    ...existingPipelines.map((p) => p.key)
-  ]);
-  for (const spec of pipelineSpecs) {
-    for (const step of spec.steps) {
-      const routeKeys = extractRoutePipelineKeys(step.advancementPolicyDefinition);
-      for (const routeKey of routeKeys) {
-        if (!knownPipelineKeys.has(routeKey)) {
-          throw new Error(`Pipeline "${spec.key}" step "${step.stepKey}" routes to pipeline "${routeKey}", but no pipeline with that key was found on the server or in the current push batch. Push the target pipeline first.`);
+  let pushedPipelinesCount = 0;
+  if (pipelineSpecs.length > 0) {
+    const existingPipelines = await pipelinesClient.listByProjectId(opts.projectId, { headers });
+    const knownPipelineKeys = new Set([
+      ...pipelineSpecs.map((s) => s.key),
+      ...existingPipelines.map((p) => p.key)
+    ]);
+    for (const spec of pipelineSpecs) {
+      for (const step of spec.steps) {
+        const routeKeys = extractRoutePipelineKeys(step.advancementPolicyDefinition);
+        for (const routeKey of routeKeys) {
+          if (!knownPipelineKeys.has(routeKey)) {
+            throw new Error(`Pipeline "${spec.key}" step "${step.stepKey}" routes to pipeline "${routeKey}", but no pipeline with that key was found on the server or in the current push batch. Push the target pipeline first.`);
+          }
         }
       }
     }
+    const serverSteps = await stepsClient.listByProjectId(opts.projectId, {
+      headers
+    });
+    const stepDefs = (serverSteps ?? []).map((s) => ({
+      id: s.id,
+      key: s.key,
+      version: s.version
+    }));
+    for (const spec of pipelineSpecs) {
+      await pipelinesClient.upsertFromSpec(opts.projectId, spec, stepDefs, {
+        headers
+      });
+      log(`\u2713 pipeline ${spec.key} v${String(spec.version)} \u2192 upserted`);
+    }
+    pushedPipelinesCount = pipelineSpecs.length;
+  }
+  let syncedDefaultPipelineAssignment = false;
+  if (hasAssignmentFile) {
+    const assignmentFilePath = join(absDir, DEFAULT_PIPELINE_ASSIGNMENT_FILENAME);
+    const assignmentMod = await import(pathToFileURL(assignmentFilePath).href);
+    const assignmentSpec = assignmentMod["default"];
+    if (!isDefaultPipelineAssignmentSpec(assignmentSpec)) {
+      throw new Error(`${DEFAULT_PIPELINE_ASSIGNMENT_FILENAME} must have a default export produced by defaultPipelineAssignment(({ assign, skip, ... }) => ({ default: ..., rules: [...] })). Got: ${typeof assignmentSpec}`);
+    }
+    syncedDefaultPipelineAssignment = await syncDefaultPipelineAssignment(assignmentSpec, opts, headers, pipelinesClient, log);
   }
-  const serverSteps = await stepsClient.listByProjectId(opts.projectId, {
+  return {
+    pushedSteps: stepMap.size,
+    pushedPipelines: pushedPipelinesCount,
+    syncedDefaultPipelineAssignment
+  };
+}
+async function syncDefaultPipelineAssignment(spec, opts, headers, pipelinesClient, log) {
+  const serialized = serializeDefaultPipelineAssignment(spec);
+  const serverPipelines = await pipelinesClient.listByProjectId(opts.projectId, {
     headers
   });
-  const stepDefs = (serverSteps ?? []).map((s) => ({
-    id: s.id,
-    key: s.key,
-    version: s.version
-  }));
-  for (const spec of pipelineSpecs) {
-    await pipelinesClient.upsertFromSpec(opts.projectId, spec, stepDefs, {
-      headers
-    });
-    log(`\u2713 pipeline ${spec.key} v${String(spec.version)} \u2192 upserted`);
+  const pipelineKeyToId = new Map(serverPipelines.map((p) => [
+    p.key,
+    p.id
+  ]));
+  const referencedKeys = new Set;
+  referencedKeys.add(serialized.linearPipelineDefinitionKey);
+  for (const rule of serialized.rulesJson.rules) {
+    if (rule.event.type === "assign" && typeof rule.event.params?.["pipelineKey"] === "string") {
+      referencedKeys.add(rule.event.params["pipelineKey"]);
+    }
+  }
+  for (const key of referencedKeys) {
+    if (!pipelineKeyToId.has(key)) {
+      throw new Error(`default-pipeline-assignment.ts references pipeline "${key}", but no pipeline with that key was found on the server. Push the pipeline first with \`boboddy pipelines push\`.`);
+    }
+  }
+  const linearPipelineDefinitionId = pipelineKeyToId.get(serialized.linearPipelineDefinitionKey);
+  const resolvedRules = serialized.rulesJson.rules.map((rule) => {
+    if (rule.event.type === "assign" && typeof rule.event.params?.["pipelineKey"] === "string") {
+      const pKey = rule.event.params["pipelineKey"];
+      const pId = pipelineKeyToId.get(pKey);
+      if (!pId) {
+        throw new Error(`default-pipeline-assignment.ts assign() references pipeline "${pKey}" which was not found on the server.`);
+      }
+      return {
+        ...rule,
+        event: {
+          ...rule.event,
+          params: {
+            ...rule.event.params,
+            pipelineDefinitionId: pId
+          }
+        }
+      };
+    }
+    return rule;
+  });
+  const projectsClient = new Projects({
+    client: createClient({ baseUrl: opts.baseUrl })
+  });
+  const result = await projectsClient.updateProjectDefaultPipelineAssignment({
+    path: { projectId: opts.projectId },
+    body: {
+      defaultPipelineAssignment: {
+        linearPipelineDefinitionId,
+        rulesJson: { rules: resolvedRules },
+        defaultEventType: serialized.defaultEventType,
+        defaultEventParamsJson: serialized.defaultEventParamsJson,
+        allowedEventTypes: serialized.allowedEventTypes
+      }
+    },
+    headers
+  });
+  if (result.error) {
+    throw new Error(`Failed to update project default pipeline assignment: ${JSON.stringify(result.error)}`);
   }
-  return { pushedSteps: stepMap.size, pushedPipelines: pipelineSpecs.length };
+  log(`\u2713 default pipeline assignment \u2192 synced (primary pipeline: ${serialized.linearPipelineDefinitionKey})`);
+  return true;
 }
 export {
   pushFromDirectory

package/dist/push/push-from-directory.d.ts

@@ -8,11 +8,17 @@ export interface PushFromDirectoryOptions {
 export interface PushFromDirectoryResult {
     pushedSteps: number;
     pushedPipelines: number;
+    /** true if the default pipeline assignment was synced to the server. */
+    syncedDefaultPipelineAssignment: boolean;
 }
 /**
- * Imports every `.ts`/`.js` file in `dir` (except the push script itself),
- * collects all pipeline and step definitions, then upserts them via the
- * strongly-typed SDK clients.
+ * Imports every `.ts`/`.js` file in `dir` (except the push script itself and
+ * `default-pipeline-assignment.ts`), collects all pipeline and step
+ * definitions, then upserts them via the strongly-typed SDK clients.
+ *
+ * If `default-pipeline-assignment.ts` is present, it is imported separately
+ * after pipelines are pushed, and the project default pipeline assignment is
+ * updated on the server.
  *
  * Designed to run on the user's native runtime (bun, node-with-tsx, deno),
  * NOT inside a `bun --compile`'d binary — that runtime can't resolve scoped

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@boboddy/sdk",
-  "version": "0.1.38-alpha",
+  "version": "0.1.39-alpha",
   "type": "module",
   "exports": {
     ".": {