TypeScript SDK

npm install @strait/ts
# or
bun add @strait/ts

import { createClientFromConfigFile } from "@strait/ts/node";

const client = await createClientFromConfigFile();

import { createClientFromEnv } from "@strait/ts/node";

// Reads STRAIT_BASE_URL, STRAIT_API_KEY, STRAIT_AUTH_TYPE, STRAIT_TIMEOUT_MS
const client = createClientFromEnv();

import { createClient } from "@strait/ts";

const client = createClient({
  baseUrl: "https://api.strait.dev",
  auth: { type: "bearer", token: process.env.STRAIT_API_KEY! },
  timeoutMs: 30_000,
});

const job = await client.createJob({
  body: {
    project_id: "proj_1",
    name: "Sync inventory",
    slug: "sync-inventory",
    endpoint_url: "https://worker.example/jobs/sync",
  },
});

const jobs = await client.jobs.list({ query: { project_id: "proj_1" } });

const result = await client.createJobResult({
  body: { project_id: "proj_1", name: "...", slug: "...", endpoint_url: "..." },
});

if (!result.ok) {
  console.error(result.error);
}

import { defineJob, zodSchema } from "@strait/ts";
import { z } from "zod";

const syncInventory = defineJob({
  name: "Sync Inventory",
  slug: "sync-inventory",
  endpointUrl: "https://worker.dev/jobs/sync",
  projectId: "proj_1",
  schema: zodSchema(z.object({ sku: z.string() })),
  maxConcurrency: 5,
  maxAttempts: 5,
  retryStrategy: "exponential",
  timeoutSecs: 300,

  run: async (payload, ctx) => {
    ctx.logger.info("Starting sync", { sku: payload.sku });
    await ctx.reportProgress(0.5);
    const result = await fetchInventory(payload.sku);
    return { synced: true, count: result.items.length };
  },

  onSuccess: async ({ output }) => console.log("Synced", output.count, "items"),
  onFailure: async ({ error }) => alertOncall(error),
});

// Register, trigger, wait
await syncInventory.register(client);
const run = await syncInventory.trigger(client, { payload: { sku: "ABC-123" } });
const completed = await syncInventory.triggerAndWait(client, { payload: { sku: "ABC-123" } });

import { defineWorkflow, step } from "@strait/ts";

const pipeline = defineWorkflow({
  name: "Order Pipeline",
  slug: "order-pipeline",
  projectId: "proj_1",
  steps: [
    step.job("validate", "job_validate"),
    step.job("charge", "job_charge", { dependsOn: ["validate"] }),
    step.approval("review", { dependsOn: ["charge"], approvalTimeoutSecs: 3600 }),
    step.waitForEvent("shipping", "shipping.confirmed", { dependsOn: ["review"] }),
    step.sleep("cooldown", 60, { dependsOn: ["shipping"] }),
  ],
});
// DAG is validated at definition time

import { withRetry, waitForRun, paginate, collectAll } from "@strait/ts";

// Retry with jitter
const run = await withRetry(
  () => client.triggerJob({ pathParams: { jobID: "job_1" }, body: { payload: { sku: "A" } } }),
  { attempts: 5, delayMs: 250, jitter: "full" }
);

// Wait for run completion
await waitForRun(client.getRun, run.id, { timeoutMs: 120_000 });

// Paginate
for await (const r of paginate((q) => client.listRuns({ query: q }))) {
  console.log(r.id, r.status);
}
const all = await collectAll(paginate((q) => client.listRuns({ query: q })));

import { canTransitionRun, isTerminalRunStatus, runMachine } from "@strait/ts";
import { createActor } from "xstate";

canTransitionRun("executing", "COMPLETE"); // true
isTerminalRunStatus("completed"); // true

const actor = createActor(runMachine);
actor.start();
actor.send({ type: "ENQUEUE" });
actor.send({ type: "DEQUEUE" });
actor.send({ type: "EXECUTE" });
actor.getSnapshot().value; // "executing"

const client = createClient({
  baseUrl: "https://api.strait.dev",
  auth: { type: "bearer", token: "..." },
}, {
  middleware: [{
    onRequest: ({ method, url }) => console.log(`-> ${method} ${url}`),
    onResponse: ({ status, durationMs }) => console.log(`<- ${status} (${durationMs}ms)`),
    onError: ({ error }) => console.error(error),
  }],
});

import { NotFoundError, UnauthorizedError, RateLimitedError } from "@strait/ts";

try {
  await client.getJob({ pathParams: { jobID: "nonexistent" } });
} catch (e) {
  if (e instanceof NotFoundError) console.log("Not found:", e.message);
  if (e instanceof RateLimitedError) console.log("Rate limited:", e.message);
}