@scalepad/sdk-core 0.1.0

package/src/index.ts

@@ -0,0 +1,87 @@
+import {
+  GeneratedCoreClient,
+  type GetclientsbyidResponse as GetClientResponse,
+  type ListassetshardwareQuery as ListHardwareAssetsQuery,
+  type ListassetshardwareResponse as ListHardwareAssetsResponse,
+  type ListclientsQuery as ListClientsQuery,
+  type ListclientsResponse as ListClientsResponse,
+  type ListintegrationsconfigurationsResponse as ListIntegrationConfigurationsResponse,
+  type ListserviceticketsQuery as ListTicketsQuery,
+  type ListserviceticketsResponse as ListTicketsResponse
+} from "./generated.js";
+import type { BaseClientConfig } from "./runtime.js";
+
+export { coreOperations, type GeneratedOperation as GeneratedCoreOperation } from "./catalog.js";
+export { GeneratedCoreClient } from "./generated.js";
+export { BaseApiError as ScalepadApiError, 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 CoreClientConfig extends BaseClientConfig {}
+
+export interface PaginatedResponse<T = Record<string, unknown>> {
+  data: T[];
+  total_count?: number;
+  next_cursor?: string | null;
+  [key: string]: unknown;
+}
+
+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 ScalepadCoreClient {
+  private readonly generated: GeneratedCoreClient;
+
+  public constructor(config: CoreClientConfig) {
+    this.generated = new GeneratedCoreClient(config);
+  }
+
+  public listClients(query: ListQuery = {}): Promise<ListClientsResponse> {
+    return this.generated.listClients(buildListQuery(query) as ListClientsQuery);
+  }
+
+  public getClient(id: string): Promise<GetClientResponse> {
+    return this.generated.getClientsById({ id });
+  }
+
+  public listIntegrationConfigurations(): Promise<ListIntegrationConfigurationsResponse> {
+    return this.generated.listIntegrationsConfigurations();
+  }
+
+  public listHardwareAssets(query: ListQuery = {}): Promise<ListHardwareAssetsResponse> {
+    return this.generated.listAssetsHardware(buildListQuery(query) as ListHardwareAssetsQuery);
+  }
+
+  public listTickets(query: ListQuery = {}): Promise<ListTicketsResponse> {
+    return this.generated.listServiceTickets(buildListQuery(query) as ListTicketsQuery);
+  }
+}
+
+export function createCoreClient(config: CoreClientConfig): ScalepadCoreClient {
+  return new ScalepadCoreClient(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
+      );
+    }
+  }
+}