coalesce-transform-mcp 0.1.0

package/dist/client.js

@@ -0,0 +1,212 @@
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_REQUEST_BODY_BYTES = 512 * 1024; // 512 KB
+function getMaxRequestBodyBytes() {
+    const raw = process.env.COALESCE_MCP_MAX_REQUEST_BODY_BYTES;
+    if (!raw)
+        return DEFAULT_MAX_REQUEST_BODY_BYTES;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return DEFAULT_MAX_REQUEST_BODY_BYTES;
+    return parsed;
+}
+const MAX_RETRY_ATTEMPTS = 5;
+const RETRY_BASE_DELAY_MS = 1_000;
+const RETRY_MAX_DELAY_MS = 30_000;
+const RETRYABLE_RATE_LIMIT_METHODS = new Set(["GET"]);
+export function validateConfig() {
+    const accessToken = process.env.COALESCE_ACCESS_TOKEN;
+    const baseUrl = process.env.COALESCE_BASE_URL;
+    if (!accessToken) {
+        throw new Error("COALESCE_ACCESS_TOKEN environment variable is required. " +
+            "Generate a token from the Deploy tab in Coalesce.");
+    }
+    if (!baseUrl) {
+        throw new Error("COALESCE_BASE_URL environment variable is required. " +
+            "Example: https://app.coalescesoftware.io");
+    }
+    return {
+        accessToken,
+        baseUrl: baseUrl.replace(/\/+$/, ""),
+    };
+}
+export class CoalesceApiError extends Error {
+    status;
+    detail;
+    constructor(message, status, detail) {
+        super(message);
+        this.status = status;
+        this.detail = detail;
+        this.name = "CoalesceApiError";
+    }
+}
+function parseRetryAfterMs(header) {
+    if (!header)
+        return undefined;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return Math.ceil(seconds * 1000);
+    }
+    // Retry-After can also be an HTTP-date; fall back to undefined
+    return undefined;
+}
+function retryDelayMs(attempt, retryAfterMs) {
+    if (retryAfterMs !== undefined && retryAfterMs > 0) {
+        return Math.min(retryAfterMs, RETRY_MAX_DELAY_MS);
+    }
+    // Exponential backoff: 1s, 2s, 4s, 8s, ...
+    return Math.min(RETRY_BASE_DELAY_MS * Math.pow(2, attempt), RETRY_MAX_DELAY_MS);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shouldRetryRateLimit(method) {
+    return RETRYABLE_RATE_LIMIT_METHODS.has(method);
+}
+async function handleResponse(response) {
+    if (response.status === 204) {
+        return { message: "Operation completed successfully" };
+    }
+    if (!response.ok) {
+        let detail;
+        try {
+            detail = await response.json();
+        }
+        catch {
+            detail = undefined;
+        }
+        switch (response.status) {
+            case 400:
+                // Include full validation body in error message for debugging
+                const message = detail && typeof detail === "object" && "message" in detail
+                    ? String(detail.message)
+                    : "Bad request";
+                const fullMessage = detail && typeof detail === "object"
+                    ? `${message}\n\nValidation details: ${JSON.stringify(detail, null, 2)}`
+                    : message;
+                throw new CoalesceApiError(fullMessage, 400, detail);
+            case 401:
+                throw new CoalesceApiError("Invalid or expired access token", 401, detail);
+            case 403:
+                throw new CoalesceApiError("Insufficient permissions for this operation", 403, detail);
+            case 404:
+                throw new CoalesceApiError("Resource not found", 404, detail);
+            case 429: {
+                const retryAfterHeader = response.headers.get("Retry-After");
+                const retryAfterMs = parseRetryAfterMs(retryAfterHeader);
+                throw new CoalesceApiError("Coalesce API rate limit exceeded", 429, { ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), ...(detail && typeof detail === "object" ? detail : {}) });
+            }
+            default:
+                throw new CoalesceApiError(`Coalesce API unavailable (HTTP ${response.status})`, response.status, detail);
+        }
+    }
+    return response.json();
+}
+export function createClient(config) {
+    const defaultRequestTimeoutMs = Math.max(1, Math.floor(config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS));
+    function buildUrl(path, params) {
+        const url = new URL(path, config.baseUrl);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        return url.toString();
+    }
+    function headers(method) {
+        const h = {
+            Authorization: `Bearer ${config.accessToken}`,
+            Accept: "application/json",
+        };
+        if (method === "POST" || method === "PUT" || method === "PATCH") {
+            h["Content-Type"] = "application/json";
+        }
+        return h;
+    }
+    function effectiveTimeoutMs(options) {
+        if (options?.timeoutMs === undefined) {
+            return defaultRequestTimeoutMs;
+        }
+        return Math.max(1, Math.min(defaultRequestTimeoutMs, Math.floor(options.timeoutMs)));
+    }
+    async function requestOnce(method, path, params, body, options) {
+        const timeoutMs = effectiveTimeoutMs(options);
+        const serializedBody = body !== undefined ? JSON.stringify(body) : undefined;
+        if (serializedBody !== undefined) {
+            const maxBytes = getMaxRequestBodyBytes();
+            const bodyBytes = Buffer.byteLength(serializedBody, "utf8");
+            if (bodyBytes > maxBytes) {
+                const sizeMB = (bodyBytes / (1024 * 1024)).toFixed(2);
+                const limitKB = Math.round(maxBytes / 1024);
+                throw new CoalesceApiError(`Request body exceeds ${limitKB} KB limit (got ${sizeMB} MB). ` +
+                    `This usually means a large cached response was accidentally passed as tool input. ` +
+                    `Override with COALESCE_MCP_MAX_REQUEST_BODY_BYTES if this payload is intentional.`, 413, { bodyBytes, maxBytes, method, path });
+            }
+        }
+        const controller = new AbortController();
+        const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
+        timeoutHandle.unref?.();
+        try {
+            const response = await fetch(buildUrl(path, params), {
+                method,
+                headers: headers(method),
+                body: serializedBody,
+                signal: controller.signal,
+            });
+            return await handleResponse(response);
+        }
+        catch (error) {
+            if (error instanceof CoalesceApiError) {
+                throw error;
+            }
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new CoalesceApiError(`Coalesce API request timed out after ${timeoutMs}ms`, 408, { method, path });
+            }
+            throw new CoalesceApiError("Unable to reach Coalesce API", 503, error instanceof Error ? { message: error.message } : error);
+        }
+        finally {
+            clearTimeout(timeoutHandle);
+        }
+    }
+    async function request(method, path, params, body, options) {
+        for (let attempt = 0; attempt < MAX_RETRY_ATTEMPTS; attempt++) {
+            try {
+                return await requestOnce(method, path, params, body, options);
+            }
+            catch (error) {
+                if (error instanceof CoalesceApiError &&
+                    error.status === 429 &&
+                    shouldRetryRateLimit(method) &&
+                    attempt < MAX_RETRY_ATTEMPTS - 1) {
+                    const detail = error.detail;
+                    const retryAfterMs = typeof detail?.retryAfterMs === "number"
+                        ? detail.retryAfterMs
+                        : undefined;
+                    await sleep(retryDelayMs(attempt, retryAfterMs));
+                    continue;
+                }
+                throw error;
+            }
+        }
+        // Unreachable, but satisfies TypeScript
+        throw new CoalesceApiError("Unexpected retry loop exit", 500);
+    }
+    return {
+        async get(path, params, options) {
+            return request("GET", path, params, undefined, options);
+        },
+        async post(path, body, params, options) {
+            return request("POST", path, params, body, options);
+        },
+        async put(path, body, params, options) {
+            return request("PUT", path, params, body, options);
+        },
+        async patch(path, body, params, options) {
+            return request("PATCH", path, params, body, options);
+        },
+        async delete(path, params, options) {
+            return request("DELETE", path, params, undefined, options);
+        },
+    };
+}

package/dist/coalesce/api/environments.d.ts

@@ -0,0 +1,20 @@
+import type { CoalesceClient, QueryParams } from "../../client.js";
+export declare function listEnvironments(client: CoalesceClient, params: QueryParams): Promise<unknown>;
+export declare function getEnvironment(client: CoalesceClient, params: {
+    environmentID: string;
+}): Promise<unknown>;
+export declare function createEnvironment(client: CoalesceClient, params: {
+    project: string;
+    name: string;
+    oauthEnabled?: boolean;
+    devEnv?: boolean;
+    connectionAccount?: string;
+    runTimeParameters?: Record<string, unknown>;
+    tagColors?: {
+        backgroundColor?: string;
+        textColor?: string;
+    };
+}): Promise<unknown>;
+export declare function deleteEnvironment(client: CoalesceClient, params: {
+    environmentID: string;
+}): Promise<unknown>;

package/dist/coalesce/api/environments.js

@@ -0,0 +1,15 @@
+import { validatePathSegment } from "../types.js";
+export async function listEnvironments(client, params) {
+    return client.get("/api/v1/environments", params);
+}
+export async function getEnvironment(client, params) {
+    const { environmentID } = params;
+    return client.get(`/api/v1/environments/${validatePathSegment(environmentID, "environmentID")}`, {});
+}
+export async function createEnvironment(client, params) {
+    return client.post("/api/v1/environments", params);
+}
+export async function deleteEnvironment(client, params) {
+    const { environmentID } = params;
+    return client.delete(`/api/v1/environments/${validatePathSegment(environmentID, "environmentID")}`);
+}

package/dist/coalesce/api/git-accounts.d.ts

@@ -0,0 +1,21 @@
+import type { CoalesceClient } from "../../client.js";
+export declare function listGitAccounts(client: CoalesceClient, params?: {
+    accountOwner?: string;
+}): Promise<unknown>;
+export declare function getGitAccount(client: CoalesceClient, params: {
+    gitAccountID: string;
+    accountOwner?: string;
+}): Promise<unknown>;
+export declare function createGitAccount(client: CoalesceClient, params: {
+    body: Record<string, unknown>;
+    accountOwner?: string;
+}): Promise<unknown>;
+export declare function updateGitAccount(client: CoalesceClient, params: {
+    gitAccountID: string;
+    body: Record<string, unknown>;
+    accountOwner?: string;
+}): Promise<unknown>;
+export declare function deleteGitAccount(client: CoalesceClient, params: {
+    gitAccountID: string;
+    accountOwner?: string;
+}): Promise<unknown>;

package/dist/coalesce/api/git-accounts.js

@@ -0,0 +1,21 @@
+import { validatePathSegment } from "../types.js";
+export async function listGitAccounts(client, params) {
+    return client.get("/api/v1/gitAccounts", {
+        ...(params?.accountOwner !== undefined ? { accountOwner: params.accountOwner } : {}),
+    });
+}
+export async function getGitAccount(client, params) {
+    return client.get(`/api/v1/gitAccounts/${validatePathSegment(params.gitAccountID, "gitAccountID")}`, {
+        ...(params.accountOwner !== undefined ? { accountOwner: params.accountOwner } : {}),
+    });
+}
+export async function createGitAccount(client, params) {
+    const qp = params.accountOwner ? { accountOwner: params.accountOwner } : undefined;
+    return client.post("/api/v1/gitAccounts", params.body, qp);
+}
+export async function updateGitAccount(client, params) {
+    return client.patch(`/api/v1/gitAccounts/${validatePathSegment(params.gitAccountID, "gitAccountID")}`, params.body, { ...(params.accountOwner !== undefined ? { accountOwner: params.accountOwner } : {}) });
+}
+export async function deleteGitAccount(client, params) {
+    return client.delete(`/api/v1/gitAccounts/${validatePathSegment(params.gitAccountID, "gitAccountID")}`, params.accountOwner ? { accountOwner: params.accountOwner } : undefined);
+}

package/dist/coalesce/api/jobs.d.ts

@@ -0,0 +1,25 @@
+import type { CoalesceClient, QueryParams } from "../../client.js";
+export declare function listEnvironmentJobs(client: CoalesceClient, params: {
+    environmentID: string;
+} & QueryParams): Promise<unknown>;
+export declare function createWorkspaceJob(client: CoalesceClient, params: {
+    workspaceID: string;
+    name: string;
+    includeSelector: string;
+    excludeSelector: string;
+}): Promise<unknown>;
+export declare function getEnvironmentJob(client: CoalesceClient, params: {
+    environmentID: string;
+    jobID: string;
+}): Promise<unknown>;
+export declare function updateWorkspaceJob(client: CoalesceClient, params: {
+    workspaceID: string;
+    jobID: string;
+    name: string;
+    includeSelector: string;
+    excludeSelector: string;
+}): Promise<unknown>;
+export declare function deleteWorkspaceJob(client: CoalesceClient, params: {
+    workspaceID: string;
+    jobID: string;
+}): Promise<unknown>;

package/dist/coalesce/api/jobs.js

@@ -0,0 +1,21 @@
+import { validatePathSegment } from "../types.js";
+export async function listEnvironmentJobs(client, params) {
+    const { environmentID, ...query } = params;
+    return client.get(`/api/v1/environments/${validatePathSegment(environmentID, "environmentID")}/jobs`, query);
+}
+export async function createWorkspaceJob(client, params) {
+    const { workspaceID, ...body } = params;
+    return client.post(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/jobs`, body);
+}
+export async function getEnvironmentJob(client, params) {
+    const { environmentID, jobID } = params;
+    return client.get(`/api/v1/environments/${validatePathSegment(environmentID, "environmentID")}/jobs/${validatePathSegment(jobID, "jobID")}`, {});
+}
+export async function updateWorkspaceJob(client, params) {
+    const { workspaceID, jobID, ...body } = params;
+    return client.put(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/jobs/${validatePathSegment(jobID, "jobID")}`, body);
+}
+export async function deleteWorkspaceJob(client, params) {
+    const { workspaceID, jobID } = params;
+    return client.delete(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/jobs/${validatePathSegment(jobID, "jobID")}`);
+}

package/dist/coalesce/api/nodes.d.ts

@@ -0,0 +1,29 @@
+import type { CoalesceClient, QueryParams } from "../../client.js";
+export declare function listEnvironmentNodes(client: CoalesceClient, params: QueryParams & {
+    environmentID: string;
+}): Promise<unknown>;
+export declare function listWorkspaceNodes(client: CoalesceClient, params: QueryParams & {
+    workspaceID: string;
+}): Promise<unknown>;
+export declare function getEnvironmentNode(client: CoalesceClient, params: {
+    environmentID: string;
+    nodeID: string;
+}): Promise<unknown>;
+export declare function getWorkspaceNode(client: CoalesceClient, params: {
+    workspaceID: string;
+    nodeID: string;
+}): Promise<unknown>;
+export declare function createWorkspaceNode(client: CoalesceClient, params: {
+    workspaceID: string;
+    nodeType: string;
+    predecessorNodeIDs?: string[];
+}): Promise<unknown>;
+export declare function setWorkspaceNode(client: CoalesceClient, params: {
+    workspaceID: string;
+    nodeID: string;
+    body: Record<string, unknown>;
+}): Promise<unknown>;
+export declare function deleteWorkspaceNode(client: CoalesceClient, params: {
+    workspaceID: string;
+    nodeID: string;
+}): Promise<unknown>;

package/dist/coalesce/api/nodes.js

@@ -0,0 +1,33 @@
+import { validatePathSegment } from "../types.js";
+export async function listEnvironmentNodes(client, params) {
+    const { environmentID, ...queryParams } = params;
+    return client.get(`/api/v1/environments/${validatePathSegment(environmentID, "environmentID")}/nodes`, queryParams);
+}
+export async function listWorkspaceNodes(client, params) {
+    const { workspaceID, ...queryParams } = params;
+    return client.get(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/nodes`, queryParams);
+}
+export async function getEnvironmentNode(client, params) {
+    const { environmentID, nodeID } = params;
+    return client.get(`/api/v1/environments/${validatePathSegment(environmentID, "environmentID")}/nodes/${validatePathSegment(nodeID, "nodeID")}`, {});
+}
+export async function getWorkspaceNode(client, params) {
+    const { workspaceID, nodeID } = params;
+    return client.get(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/nodes/${validatePathSegment(nodeID, "nodeID")}`, {});
+}
+export async function createWorkspaceNode(client, params) {
+    const { workspaceID, nodeType, predecessorNodeIDs } = params;
+    const payload = { nodeType };
+    if (predecessorNodeIDs !== undefined) {
+        payload.predecessorNodeIDs = predecessorNodeIDs;
+    }
+    return client.post(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/nodes`, payload);
+}
+export async function setWorkspaceNode(client, params) {
+    const { workspaceID, nodeID, body } = params;
+    return client.put(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/nodes/${validatePathSegment(nodeID, "nodeID")}`, body);
+}
+export async function deleteWorkspaceNode(client, params) {
+    const { workspaceID, nodeID } = params;
+    return client.delete(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/nodes/${validatePathSegment(nodeID, "nodeID")}`);
+}

package/dist/coalesce/api/projects.d.ts

@@ -0,0 +1,22 @@
+import type { CoalesceClient } from "../../client.js";
+export declare function listProjects(client: CoalesceClient, params?: {
+    includeWorkspaces?: boolean;
+    includeJobs?: boolean;
+}): Promise<unknown>;
+export declare function getProject(client: CoalesceClient, params: {
+    projectID: string;
+    includeWorkspaces?: boolean;
+    includeJobs?: boolean;
+}): Promise<unknown>;
+export declare function createProject(client: CoalesceClient, params: {
+    body: Record<string, unknown>;
+}): Promise<unknown>;
+export declare function updateProject(client: CoalesceClient, params: {
+    projectID: string;
+    body: Record<string, unknown>;
+    includeWorkspaces?: boolean;
+    includeJobs?: boolean;
+}): Promise<unknown>;
+export declare function deleteProject(client: CoalesceClient, params: {
+    projectID: string;
+}): Promise<unknown>;

package/dist/coalesce/api/projects.js

@@ -0,0 +1,25 @@
+import { validatePathSegment } from "../types.js";
+export async function listProjects(client, params) {
+    return client.get("/api/v1/projects", {
+        ...(params?.includeWorkspaces !== undefined ? { includeWorkspaces: params.includeWorkspaces } : {}),
+        ...(params?.includeJobs !== undefined ? { includeJobs: params.includeJobs } : {}),
+    });
+}
+export async function getProject(client, params) {
+    return client.get(`/api/v1/projects/${validatePathSegment(params.projectID, "projectID")}`, {
+        ...(params.includeWorkspaces !== undefined ? { includeWorkspaces: params.includeWorkspaces } : {}),
+        ...(params.includeJobs !== undefined ? { includeJobs: params.includeJobs } : {}),
+    });
+}
+export async function createProject(client, params) {
+    return client.post("/api/v1/projects", params.body);
+}
+export async function updateProject(client, params) {
+    return client.patch(`/api/v1/projects/${validatePathSegment(params.projectID, "projectID")}`, params.body, {
+        ...(params.includeWorkspaces !== undefined ? { includeWorkspaces: params.includeWorkspaces } : {}),
+        ...(params.includeJobs !== undefined ? { includeJobs: params.includeJobs } : {}),
+    });
+}
+export async function deleteProject(client, params) {
+    return client.delete(`/api/v1/projects/${validatePathSegment(params.projectID, "projectID")}`);
+}

package/dist/coalesce/api/runs.d.ts

@@ -0,0 +1,19 @@
+import type { CoalesceClient, QueryParams } from "../../client.js";
+import type { StartRunInput, RerunInput } from "../types.js";
+export declare function listRuns(client: CoalesceClient, params: QueryParams): Promise<unknown>;
+export declare function getRun(client: CoalesceClient, params: {
+    runID: string;
+}): Promise<unknown>;
+export declare function getRunResults(client: CoalesceClient, params: {
+    runID: string;
+}): Promise<unknown>;
+export declare function startRun(client: CoalesceClient, params: StartRunInput): Promise<unknown>;
+export declare function runStatus(client: CoalesceClient, params: {
+    runCounter: number;
+}): Promise<unknown>;
+export declare function retryRun(client: CoalesceClient, params: RerunInput): Promise<unknown>;
+export declare function cancelRun(client: CoalesceClient, params: {
+    runID: string;
+    orgID?: string;
+    environmentID: string;
+}): Promise<unknown>;

package/dist/coalesce/api/runs.js

@@ -0,0 +1,34 @@
+import { validatePathSegment, buildStartRunBody, buildRerunBody } from "../types.js";
+export async function listRuns(client, params) {
+    return client.get("/api/v1/runs", params);
+}
+export async function getRun(client, params) {
+    const { runID } = params;
+    return client.get(`/api/v1/runs/${validatePathSegment(runID, "runID")}`, {});
+}
+export async function getRunResults(client, params) {
+    const { runID } = params;
+    return client.get(`/api/v1/runs/${validatePathSegment(runID, "runID")}/results`, {});
+}
+export async function startRun(client, params) {
+    const body = buildStartRunBody(params);
+    return client.post("/scheduler/startRun", body);
+}
+export async function runStatus(client, params) {
+    return client.get("/scheduler/runStatus", { runCounter: params.runCounter });
+}
+export async function retryRun(client, params) {
+    const body = buildRerunBody(params);
+    return client.post("/scheduler/rerun", body);
+}
+export async function cancelRun(client, params) {
+    const orgID = params.orgID ?? process.env.COALESCE_ORG_ID;
+    if (!orgID) {
+        throw new Error("orgID is required for cancel-run. Provide it explicitly or set COALESCE_ORG_ID.");
+    }
+    return client.post("/scheduler/cancelRun", {
+        runID: params.runID,
+        orgID,
+        environmentID: params.environmentID,
+    });
+}

package/dist/coalesce/api/subgraphs.d.ts

@@ -0,0 +1,20 @@
+import type { CoalesceClient } from "../../client.js";
+export declare function getWorkspaceSubgraph(client: CoalesceClient, params: {
+    workspaceID: string;
+    subgraphID: string;
+}): Promise<unknown>;
+export declare function createWorkspaceSubgraph(client: CoalesceClient, params: {
+    workspaceID: string;
+    name: string;
+    steps: string[];
+}): Promise<unknown>;
+export declare function updateWorkspaceSubgraph(client: CoalesceClient, params: {
+    workspaceID: string;
+    subgraphID: string;
+    name: string;
+    steps: string[];
+}): Promise<unknown>;
+export declare function deleteWorkspaceSubgraph(client: CoalesceClient, params: {
+    workspaceID: string;
+    subgraphID: string;
+}): Promise<unknown>;

package/dist/coalesce/api/subgraphs.js

@@ -0,0 +1,17 @@
+import { validatePathSegment } from "../types.js";
+export async function getWorkspaceSubgraph(client, params) {
+    const { workspaceID, subgraphID } = params;
+    return client.get(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/subgraphs/${validatePathSegment(subgraphID, "subgraphID")}`, {});
+}
+export async function createWorkspaceSubgraph(client, params) {
+    const { workspaceID, ...body } = params;
+    return client.post(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/subgraphs`, body);
+}
+export async function updateWorkspaceSubgraph(client, params) {
+    const { workspaceID, subgraphID, ...body } = params;
+    return client.put(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/subgraphs/${validatePathSegment(subgraphID, "subgraphID")}`, body);
+}
+export async function deleteWorkspaceSubgraph(client, params) {
+    const { workspaceID, subgraphID } = params;
+    return client.delete(`/api/v1/workspaces/${validatePathSegment(workspaceID, "workspaceID")}/subgraphs/${validatePathSegment(subgraphID, "subgraphID")}`);
+}

package/dist/coalesce/api/users.d.ts

@@ -0,0 +1,30 @@
+import type { CoalesceClient, QueryParams } from "../../client.js";
+export declare function listOrgUsers(client: CoalesceClient, params: QueryParams): Promise<unknown>;
+export declare function getUserRoles(client: CoalesceClient, params: {
+    userID: string;
+    projectID?: string;
+    environmentID?: string;
+}): Promise<unknown>;
+export declare function listUserRoles(client: CoalesceClient, params: QueryParams): Promise<unknown>;
+export declare function setOrgRole(client: CoalesceClient, params: {
+    userID: string;
+    body: Record<string, unknown>;
+}): Promise<unknown>;
+export declare function setProjectRole(client: CoalesceClient, params: {
+    userID: string;
+    projectID: string;
+    body: Record<string, unknown>;
+}): Promise<unknown>;
+export declare function deleteProjectRole(client: CoalesceClient, params: {
+    userID: string;
+    projectID: string;
+}): Promise<unknown>;
+export declare function setEnvRole(client: CoalesceClient, params: {
+    userID: string;
+    environmentID: string;
+    body: Record<string, unknown>;
+}): Promise<unknown>;
+export declare function deleteEnvRole(client: CoalesceClient, params: {
+    userID: string;
+    environmentID: string;
+}): Promise<unknown>;

package/dist/coalesce/api/users.js

@@ -0,0 +1,31 @@
+import { validatePathSegment } from "../types.js";
+export async function listOrgUsers(client, params) {
+    return client.get("/api/v1/users", params);
+}
+export async function getUserRoles(client, params) {
+    const { userID, ...queryParams } = params;
+    return client.get(`/api/v2/userRoles/${validatePathSegment(userID, "userID")}`, queryParams);
+}
+export async function listUserRoles(client, params) {
+    return client.get("/api/v2/userRoles", params);
+}
+export async function setOrgRole(client, params) {
+    const { userID, body } = params;
+    return client.put(`/api/v2/userRoles/${validatePathSegment(userID, "userID")}/organizationRole`, body);
+}
+export async function setProjectRole(client, params) {
+    const { userID, projectID, body } = params;
+    return client.put(`/api/v2/userRoles/${validatePathSegment(userID, "userID")}/projects/${validatePathSegment(projectID, "projectID")}`, body);
+}
+export async function deleteProjectRole(client, params) {
+    const { userID, projectID } = params;
+    return client.delete(`/api/v2/userRoles/${validatePathSegment(userID, "userID")}/projects/${validatePathSegment(projectID, "projectID")}`);
+}
+export async function setEnvRole(client, params) {
+    const { userID, environmentID, body } = params;
+    return client.put(`/api/v2/userRoles/${validatePathSegment(userID, "userID")}/environments/${validatePathSegment(environmentID, "environmentID")}`, body);
+}
+export async function deleteEnvRole(client, params) {
+    const { userID, environmentID } = params;
+    return client.delete(`/api/v2/userRoles/${validatePathSegment(userID, "userID")}/environments/${validatePathSegment(environmentID, "environmentID")}`);
+}