@scalepad/sdk-lm 0.1.0

package/src/index.ts

@@ -0,0 +1,63 @@
+import {
+  GeneratedLifecycleManagerClient,
+  type GetactionitemsbyidResponse as GetActionItemResponse,
+  type ListactionitemsQuery as ListActionItemsQuery,
+  type ListactionitemsResponse as ListActionItemsResponse
+} from "./generated.js";
+import type { BaseClientConfig } from "./runtime.js";
+
+export { lifecycleManagerOperations, type GeneratedOperation as GeneratedLifecycleManagerOperation } from "./catalog.js";
+export { GeneratedLifecycleManagerClient } from "./generated.js";
+export { BaseApiError as ScalepadLmApiError, type FetchLike, type JsonArray, type JsonObject, type JsonPrimitive, type JsonValue } from "./runtime.js";
+export type { paths } from "./schema.js";
+
+export interface ListQuery {
+  cursor?: string;
+  pageSize?: number;
+  filters?: Record<string, string>;
+  sort?: string;
+}
+
+export interface LifecycleManagerClientConfig extends BaseClientConfig {}
+
+function buildListQuery(query: ListQuery = {}): Record<string, string> {
+  const params: Record<string, string> = {};
+
+  if (query.pageSize != null) {
+    params.page_size = String(query.pageSize);
+  }
+
+  if (query.cursor) {
+    params.cursor = query.cursor;
+  }
+
+  if (query.sort) {
+    params.sort = query.sort;
+  }
+
+  for (const [field, expression] of Object.entries(query.filters ?? {})) {
+    params[`filter[${field}]`] = expression;
+  }
+
+  return params;
+}
+
+export class ScalepadLifecycleManagerClient {
+  private readonly generated: GeneratedLifecycleManagerClient;
+
+  public constructor(config: LifecycleManagerClientConfig) {
+    this.generated = new GeneratedLifecycleManagerClient(config);
+  }
+
+  public listActionItems(query: ListQuery = {}): Promise<ListActionItemsResponse> {
+    return this.generated.listActionItems(buildListQuery(query) as ListActionItemsQuery);
+  }
+
+  public getActionItem(id: string): Promise<GetActionItemResponse> {
+    return this.generated.getActionItemsById({ id });
+  }
+}
+
+export function createLifecycleManagerClient(config: LifecycleManagerClientConfig): ScalepadLifecycleManagerClient {
+  return new ScalepadLifecycleManagerClient(config);
+}

package/src/runtime.ts

@@ -0,0 +1,132 @@
+export type JsonPrimitive = string | number | boolean | null;
+export interface JsonObject {
+  [key: string]: JsonValue;
+}
+export interface JsonArray extends Array<JsonValue> {}
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export type FetchLike = typeof fetch;
+export type QueryArrayValue = string | number | boolean;
+export type QueryValue = string | number | boolean | null | undefined | ReadonlyArray<QueryArrayValue>;
+export type QueryParams = Record<string, QueryValue>;
+
+export class BaseApiError extends Error {
+  public readonly status: number;
+  public readonly payload: unknown;
+
+  public constructor(message: string, status: number, payload: unknown) {
+    super(message);
+    this.name = "BaseApiError";
+    this.status = status;
+    this.payload = payload;
+  }
+}
+
+export interface BaseClientConfig {
+  apiKey: string;
+  baseUrl?: string;
+  fetchImpl?: FetchLike;
+  userAgent?: string;
+  maxRetries?: number;
+}
+
+const DEFAULT_BASE_URL = "https://api.scalepad.com";
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+async function parseResponseBody(response: Response): Promise<unknown> {
+  if (response.status === 204 || response.status === 205) {
+    return null;
+  }
+
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return response.json();
+  }
+
+  const text = await response.text();
+  return text.length === 0 ? null : text;
+}
+
+function appendQuery(url: URL, query?: QueryParams): void {
+  if (!query) {
+    return;
+  }
+
+  for (const [key, value] of Object.entries(query)) {
+    if (value == null) {
+      continue;
+    }
+
+    if (Array.isArray(value)) {
+      url.searchParams.set(key, value.join(","));
+      continue;
+    }
+
+    url.searchParams.set(key, String(value));
+  }
+}
+
+export class BaseApiClient {
+  private readonly apiKey: string;
+  private readonly baseUrl: string;
+  private readonly fetchImpl: FetchLike;
+  private readonly userAgent: string;
+  private readonly maxRetries: number;
+
+  public constructor(config: BaseClientConfig) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+    this.fetchImpl = config.fetchImpl ?? fetch;
+    this.userAgent = config.userAgent ?? "@scalepad/cli";
+    this.maxRetries = config.maxRetries ?? 3;
+  }
+
+  protected async requestJson(request: {
+    method: string;
+    path: string;
+    query?: QueryParams;
+    body?: JsonValue;
+  }): Promise<unknown> {
+    const url = new URL(request.path, this.baseUrl);
+    appendQuery(url, request.query);
+
+    let attempt = 0;
+    while (true) {
+      const response = await this.fetchImpl(url, {
+        method: request.method,
+        headers: {
+          accept: "application/json",
+          ...(request.body != null ? { "content-type": "application/json" } : {}),
+          "x-api-key": this.apiKey,
+          "user-agent": this.userAgent
+        },
+        body: request.body != null ? JSON.stringify(request.body) : undefined
+      });
+
+      if (response.ok) {
+        return parseResponseBody(response);
+      }
+
+      if (response.status === 429 && attempt < this.maxRetries) {
+        attempt += 1;
+        const retryAfterSeconds = Number(response.headers.get("retry-after"));
+        const waitMs = Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0
+          ? retryAfterSeconds * 1000
+          : 500 * (2 ** (attempt - 1));
+        await delay(waitMs);
+        continue;
+      }
+
+      const payload = await parseResponseBody(response);
+      throw new BaseApiError(
+        `API request failed with status ${response.status}`,
+        response.status,
+        payload
+      );
+    }
+  }
+}