@toshicloud/sdk 0.0.0-stage → 0.2.0

package/dist/wait.js

@@ -0,0 +1,29 @@
+import { abortReason } from "./retry.js";
+/** Asks again while reached is false, and returns the response when it is (wait.go:11-27). */
+export async function waitWorkload(workspace, req, opts) {
+    for (;;) {
+        throwIfAborted(opts);
+        const resp = await workspace.waitWorkload(req, opts);
+        if (resp.reached) {
+            return resp;
+        }
+    }
+}
+/** Asks again while the operation is not done, and returns it when it is (wait.go:29-45). */
+export async function waitOperation(workspace, req, opts) {
+    for (;;) {
+        throwIfAborted(opts);
+        const resp = await workspace.waitOperation(req, opts);
+        const op = resp.operation;
+        if (op !== undefined && op.done) {
+            return op;
+        }
+    }
+}
+// wait.go:16-18: the caller's context ends the loop with its own error.
+function throwIfAborted(opts) {
+    const signal = opts?.signal;
+    if (signal?.aborted === true) {
+        throw abortReason(signal);
+    }
+}

package/dist/watch.d.ts

@@ -0,0 +1,8 @@
+import type { Client } from "@connectrpc/connect";
+import type { CallOptions, EventWatch, WorkloadWatch } from "./client.js";
+import type { WatchEventsRequest, WatchWorkloadsRequest, WorkspaceService } from "./gen/toshi/workspace/v1/workspace_pb.js";
+import type { RetrySetting } from "./retry.js";
+/** Starts a workload watch; with an empty cursor it lists the workloads first (watch.go:40-84). */
+export declare function openWorkloadWatch(workspace: Client<typeof WorkspaceService>, retry: RetrySetting, req: WatchWorkloadsRequest, opts?: CallOptions): Promise<WorkloadWatch>;
+/** Starts an event watch; with an empty cursor it pages ListEvents as the caller iterates (watch.go:261-283). */
+export declare function openEventWatch(workspace: Client<typeof WorkspaceService>, retry: RetrySetting, req: WatchEventsRequest, opts?: CallOptions): Promise<EventWatch>;

package/dist/watch.js

@@ -0,0 +1,224 @@
+import { clone, create } from "@bufbuild/protobuf";
+import { ListEventsRequestSchema, ListWorkloadsRequestSchema, WatchEventsRequestSchema, WatchWorkloadsRequestSchema, } from "./gen/toshi/workspace/v1/workspace_pb.js";
+import { READER_TAKEN, WatchState, createReader, reconnect, streamEnded } from "./stream.js";
+/** Starts a workload watch; with an empty cursor it lists the workloads first (watch.go:40-84). */
+export async function openWorkloadWatch(workspace, retry, req, opts) {
+    const state = new WatchState(req.cursor, opts?.signal);
+    let snapshot;
+    if (req.cursor === "") {
+        try {
+            const listed = await listWorkloads(workspace, req, state);
+            snapshot = listed.workloads;
+            state.cursor = listed.cursor;
+        }
+        catch (err) {
+            state.close();
+            throw err;
+        }
+    }
+    const request = clone(WatchWorkloadsRequestSchema, req);
+    request.cursor = state.cursor;
+    request.keepalive = true;
+    let reader;
+    return {
+        get cursor() {
+            return state.cursor;
+        },
+        get snapshot() {
+            return snapshot;
+        },
+        close() {
+            state.close();
+        },
+        [Symbol.asyncIterator]() {
+            if (reader !== undefined) {
+                throw new Error(READER_TAKEN);
+            }
+            reader = createReader(() => runWorkloads(workspace, retry, request, state), () => state.close());
+            return reader;
+        },
+    };
+}
+/** Starts an event watch; with an empty cursor it pages ListEvents as the caller iterates (watch.go:261-283). */
+export function openEventWatch(workspace, retry, req, opts) {
+    const state = new WatchState(req.cursor, opts?.signal);
+    const request = clone(WatchEventsRequestSchema, req);
+    request.keepalive = true;
+    const list = createListEventsRequest(req);
+    const listing = req.cursor === "";
+    let reader;
+    const watch = {
+        get cursor() {
+            return state.cursor;
+        },
+        close() {
+            state.close();
+        },
+        [Symbol.asyncIterator]() {
+            if (reader !== undefined) {
+                throw new Error(READER_TAKEN);
+            }
+            reader = createReader(() => runEvents(workspace, retry, request, list, listing, state), () => state.close());
+            return reader;
+        },
+    };
+    return Promise.resolve(watch);
+}
+// watch.go:65-84: every page of the list returns the event log's position.
+async function listWorkloads(workspace, req, state) {
+    const list = createListWorkloadsRequest(req);
+    const workloads = [];
+    for (;;) {
+        const page = await workspace.listWorkloads(list, { signal: state.signal });
+        workloads.push(...page.workloads);
+        if (page.nextPageToken === "") {
+            return { workloads, cursor: page.cursor };
+        }
+        list.pageToken = page.nextPageToken;
+    }
+}
+function createListWorkloadsRequest(req) {
+    return create(ListWorkloadsRequestSchema, {
+        project: req.project,
+        environment: req.environment,
+        kinds: req.kinds,
+    });
+}
+function createListEventsRequest(req) {
+    return create(ListEventsRequestSchema, {
+        project: req.project,
+        environment: req.environment,
+        workloadId: req.workloadId,
+    });
+}
+async function* runWorkloads(workspace, retry, request, state) {
+    let attempt = 0;
+    try {
+        for (;;) {
+            if (state.closed) {
+                return;
+            }
+            let cause;
+            try {
+                request.cursor = state.cursor;
+                const stream = workspace.watchWorkloads(request, { signal: state.signal });
+                for await (const msg of stream) {
+                    attempt = 0;
+                    if (msg.keepalive !== undefined) {
+                        if (msg.keepalive.cursor !== "") {
+                            state.cursor = msg.keepalive.cursor;
+                        }
+                        continue;
+                    }
+                    if (msg.cursor !== "") {
+                        state.cursor = msg.cursor;
+                    }
+                    yield msg;
+                }
+                if (state.closed) {
+                    return;
+                }
+                cause = streamEnded;
+            }
+            catch (err) {
+                if (state.closed) {
+                    return;
+                }
+                cause = err;
+            }
+            attempt = await reconnect(retry, attempt, cause, state);
+        }
+    }
+    catch (err) {
+        if (state.closed) {
+            return;
+        }
+        throw err;
+    }
+}
+async function* runEvents(workspace, retry, request, list, listingAtStart, state) {
+    let attempt = 0;
+    let page = [];
+    let pageIndex = 0;
+    let listing = listingAtStart;
+    // watch.go:305-317: resume is the position the next stream opens at, separate
+    // from the cursor the caller sees, which only moves on events handed out and
+    // keepalives consumed.
+    let resume = state.cursor;
+    try {
+        for (;;) {
+            if (state.closed) {
+                return;
+            }
+            let cause;
+            try {
+                if (listing) {
+                    if (pageIndex < page.length) {
+                        const event = page[pageIndex];
+                        pageIndex += 1;
+                        attempt = 0;
+                        if (event.cursor !== "") {
+                            state.cursor = event.cursor;
+                            resume = event.cursor;
+                        }
+                        yield event;
+                        continue;
+                    }
+                    const listed = await workspace.listEvents(list, { signal: state.signal });
+                    page = listed.events;
+                    pageIndex = 0;
+                    if (listed.cursor !== "") {
+                        list.cursor = listed.cursor;
+                    }
+                    if (page.length > 0) {
+                        continue;
+                    }
+                    if (listed.cursor !== "") {
+                        resume = listed.cursor;
+                    }
+                    listing = false;
+                    continue;
+                }
+                request.cursor = resume;
+                const stream = workspace.watchEvents(request, { signal: state.signal });
+                for await (const msg of stream) {
+                    attempt = 0;
+                    const keepalive = msg.keepalive;
+                    if (keepalive !== undefined) {
+                        if (keepalive.cursor !== "") {
+                            state.cursor = keepalive.cursor;
+                            resume = keepalive.cursor;
+                        }
+                        continue;
+                    }
+                    const event = msg.event;
+                    if (event === undefined) {
+                        continue;
+                    }
+                    if (event.cursor !== "") {
+                        state.cursor = event.cursor;
+                        resume = event.cursor;
+                    }
+                    yield event;
+                }
+                if (state.closed) {
+                    return;
+                }
+                cause = streamEnded;
+            }
+            catch (err) {
+                if (state.closed) {
+                    return;
+                }
+                cause = err;
+            }
+            attempt = await reconnect(retry, attempt, cause, state);
+        }
+    }
+    catch (err) {
+        if (state.closed) {
+            return;
+        }
+        throw err;
+    }
+}

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@toshicloud/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "TypeScript client for the Toshi Workspace API",
+  "license": "Apache-2.0",
+  "packageManager": "pnpm@12.15.0+sha512.b3951d6d6ff4a9f13dc7cf56cd28d2b8eb37dbcc9c68e52e1e1191873ea9f82a017287ab50baadc5ccc494f036c67c0e47eb13608c2fa36f47711b61ea128e61",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.22 <25"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toshicloud/toshi-ts.git"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "test": "vitest run --coverage",
+    "generate": "scripts/generate.sh",
+    "prepack": "pnpm run build"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "^2.16.0",
+    "@connectrpc/connect": "^2.2.0"
+  },
+  "devDependencies": {
+    "@connectrpc/connect-node": "2.2.0",
+    "@eslint/js": "10.0.1",
+    "@types/node": "26.6.5",
+    "@vitest/coverage-v8": "5.0.5",
+    "eslint": "10.13.0",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.72.0",
+    "vitest": "5.0.5"
+  }
+}