@databricks/sdk-alerts 0.0.0-dev → 0.1.0-dev.1

package/src/v1/utils.ts

@@ -0,0 +1,156 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+
+import type {Call, Options} from '@databricks/sdk-core/api';
+import {execute} from '@databricks/sdk-core/api';
+import {ApiError} from '@databricks/sdk-core/apierror';
+import type {
+  HttpClient,
+  HttpRequest,
+  HttpResponse,
+} from '@databricks/sdk-core/http';
+import type {Logger} from '@databricks/sdk-core/logger';
+import type {CallOptions} from '@databricks/sdk-options/call';
+import JSONBig from 'json-bigint';
+import type {z} from 'zod';
+
+// JSON codec that preserves int64 precision. On the way in, large integer
+// literals come back as bigint instead of being rounded to JS Number. On the
+// way out, bigint values are emitted as raw JSON number digits.
+const jsonBigint = JSONBig({useNativeBigInt: true});
+
+export interface HttpCallOptions {
+  readonly request: HttpRequest;
+  readonly httpClient: HttpClient;
+  readonly logger: Logger;
+}
+
+/**
+ * Translates public CallOptions to the internal Options shape accepted by
+ * execute(). Even though the shapes match today, this isolates the public
+ * API from the executor's internal type so they can diverge.
+ */
+export async function executeCall(
+  call: Call,
+  options?: CallOptions
+): Promise<void> {
+  const opts: Options = {
+    ...(options?.retrier !== undefined && {retrier: options.retrier}),
+    ...(options?.rateLimiter !== undefined && {
+      rateLimiter: options.rateLimiter,
+    }),
+    ...(options?.timeout !== undefined && {timeout: options.timeout}),
+  };
+  return execute(options?.signal, call, opts);
+}
+
+async function readAll(
+  body: ReadableStream<Uint8Array> | null
+): Promise<Uint8Array> {
+  if (body === null) {
+    return new Uint8Array(0);
+  }
+  const reader = body.getReader();
+  const chunks: Uint8Array[] = [];
+  for (;;) {
+    const {done, value} = await reader.read();
+    if (done) {
+      break;
+    }
+    chunks.push(value);
+  }
+  const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+
+export async function executeHttpCall(
+  opts: HttpCallOptions
+): Promise<Uint8Array> {
+  opts.logger.debug('HTTP request', {
+    method: opts.request.method,
+    url: opts.request.url,
+  });
+
+  let resp: HttpResponse;
+  try {
+    resp = await opts.httpClient.send(opts.request);
+  } catch (e: unknown) {
+    opts.logger.debug('HTTP request failed');
+    throw e;
+  }
+
+  const body = await readAll(resp.body);
+
+  opts.logger.debug('HTTP response', {
+    statusCode: resp.statusCode,
+    body: new TextDecoder().decode(body),
+  });
+
+  const apiErr = ApiError.fromHttpError(resp.statusCode, resp.headers, body);
+  if (apiErr !== undefined) {
+    throw apiErr;
+  }
+
+  return body;
+}
+
+export function buildHttpRequest(
+  method: string,
+  url: string,
+  headers: Headers,
+  signal?: AbortSignal,
+  body?: string | ReadableStream<Uint8Array>
+): HttpRequest {
+  const req: HttpRequest = {url, method, headers};
+  if (body !== undefined) {
+    req.body = body;
+  }
+  if (signal !== undefined) {
+    req.signal = signal;
+  }
+  return req;
+}
+
+export function parseResponse<T>(body: Uint8Array, schema: z.ZodType<T>): T {
+  const text = new TextDecoder().decode(body);
+  const parsed: unknown = jsonBigint.parse(text);
+  return schema.parse(parsed);
+}
+
+export function marshalRequest(data: unknown, schema: z.ZodType): string {
+  return jsonBigint.stringify(schema.parse(data));
+}
+
+export function flattenQueryParams(
+  prefix: string,
+  value: unknown,
+  params: URLSearchParams
+): void {
+  if (value === null || value === undefined) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    // arrays of objects are not yet supported
+    for (const item of value) {
+      params.append(prefix, String(item));
+    }
+  } else if (typeof value === 'object') {
+    for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+      flattenQueryParams(`${prefix}.${key}`, val, params);
+    }
+  } else if (
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    typeof value === 'boolean' ||
+    typeof value === 'bigint'
+  ) {
+    params.append(prefix, String(value));
+  } else {
+    throw new Error(`Unsupported query parameter type: ${typeof value}`);
+  }
+}

package/src/v2/client.ts

@@ -0,0 +1,253 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+
+import {VERSION as AUTH_VERSION} from '@databricks/sdk-auth';
+import type {Call} from '@databricks/sdk-core/api';
+import {createDefault} from '@databricks/sdk-core/clientinfo';
+import type {Logger} from '@databricks/sdk-core/logger';
+import {NoOpLogger} from '@databricks/sdk-core/logger';
+import type {CallOptions} from '@databricks/sdk-options/call';
+import type {ClientOptions} from '@databricks/sdk-options/client';
+import type {HttpClient} from '@databricks/sdk-core/http';
+import {newHttpClient} from './transport';
+import {
+  buildHttpRequest,
+  executeCall,
+  executeHttpCall,
+  marshalRequest,
+  parseResponse,
+} from './utils';
+import pkgJson from '../../package.json' with {type: 'json'};
+import type {
+  Alert,
+  CreateAlertRequest,
+  Empty,
+  GetAlertRequest,
+  ListAlertsRequest,
+  ListAlertsResponse,
+  TrashAlertRequest,
+  UpdateAlertRequest,
+} from './model';
+import {
+  marshalAlertSchema,
+  unmarshalAlertSchema,
+  unmarshalEmptySchema,
+  unmarshalListAlertsResponseSchema,
+} from './model';
+
+// Package identity segment for this client to be used in the User-Agent header.
+const PACKAGE_SEGMENT = {
+  key: 'sdk-js-' + pkgJson.name.replace(/^@[^/]+\/sdk-/, ''),
+  value: pkgJson.version,
+};
+
+export class AlertsClient {
+  private readonly host: string;
+  // Workspace ID used to route workspace-level calls on unified hosts (SPOG).
+  // When set, workspace-level methods send X-Databricks-Org-Id on every
+  // request.
+  private readonly workspaceId: string | undefined;
+  private readonly httpClient: HttpClient;
+  private readonly logger: Logger;
+  // User-Agent header value. Composed once at construction from
+  // createDefault() merged with this package's identity and the active
+  // credential's name.
+  private readonly userAgent: string;
+
+  constructor(options: ClientOptions) {
+    if (options.host === undefined) {
+      throw new Error('Host is required.');
+    }
+    this.host = options.host.replace(/\/$/, '');
+    this.workspaceId = options.workspaceId;
+    this.logger = options.logger ?? new NoOpLogger();
+    const info = createDefault()
+      .with(PACKAGE_SEGMENT)
+      .with({key: 'sdk-js-auth', value: AUTH_VERSION})
+      .with({key: 'auth', value: options.credentials?.name() ?? 'default'});
+    this.userAgent = info.toString();
+    this.httpClient = newHttpClient(options);
+  }
+
+  /** Create Alert */
+  async createAlert(
+    req: CreateAlertRequest,
+    options?: CallOptions
+  ): Promise<Alert> {
+    const url = `${this.host}/api/2.0/alerts`;
+    const body = marshalRequest(req.alert, marshalAlertSchema);
+    let resp: Alert | undefined;
+    const call: Call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers({'Content-Type': 'application/json'});
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('POST', url, headers, callSignal, body);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(respBody, unmarshalAlertSchema);
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('API call completed without a result.');
+    }
+    return resp;
+  }
+
+  /** Gets an alert. */
+  async getAlert(req: GetAlertRequest, options?: CallOptions): Promise<Alert> {
+    const url = `${this.host}/api/2.0/alerts/${req.id ?? ''}`;
+    let resp: Alert | undefined;
+    const call: Call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers();
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('GET', url, headers, callSignal);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(respBody, unmarshalAlertSchema);
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('API call completed without a result.');
+    }
+    return resp;
+  }
+
+  /** Gets a list of alerts accessible to the user, ordered by creation time. */
+  async listAlerts(
+    req: ListAlertsRequest,
+    options?: CallOptions
+  ): Promise<ListAlertsResponse> {
+    const url = `${this.host}/api/2.0/alerts`;
+    const params = new URLSearchParams();
+    if (req.pageToken !== undefined) {
+      params.append('page_token', req.pageToken);
+    }
+    if (req.pageSize !== undefined) {
+      params.append('page_size', String(req.pageSize));
+    }
+    const query = params.toString();
+    const fullUrl = query !== '' ? `${url}?${query}` : url;
+    let resp: ListAlertsResponse | undefined;
+    const call: Call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers();
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('GET', fullUrl, headers, callSignal);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(respBody, unmarshalListAlertsResponseSchema);
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('API call completed without a result.');
+    }
+    return resp;
+  }
+
+  async *listAlertsIter(
+    req: ListAlertsRequest,
+    options?: CallOptions
+  ): AsyncGenerator<Alert> {
+    const pageReq: ListAlertsRequest = {...req};
+    for (;;) {
+      const resp = await this.listAlerts(pageReq, options);
+      for (const item of resp.alerts ?? []) {
+        yield item;
+      }
+      if (resp.nextPageToken === undefined || resp.nextPageToken === '') {
+        return;
+      }
+      pageReq.pageToken = resp.nextPageToken;
+    }
+  }
+
+  /** Moves an alert to the trash. Trashed alerts immediately disappear from list views, and can no longer trigger. You can restore a trashed alert through the UI. A trashed alert is permanently deleted after 30 days. */
+  async trashAlert(
+    req: TrashAlertRequest,
+    options?: CallOptions
+  ): Promise<Empty> {
+    const url = `${this.host}/api/2.0/alerts/${req.id ?? ''}`;
+    const params = new URLSearchParams();
+    if (req.purge !== undefined) {
+      params.append('purge', String(req.purge));
+    }
+    const query = params.toString();
+    const fullUrl = query !== '' ? `${url}?${query}` : url;
+    let resp: Empty | undefined;
+    const call: Call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers();
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('DELETE', fullUrl, headers, callSignal);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(respBody, unmarshalEmptySchema);
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('API call completed without a result.');
+    }
+    return resp;
+  }
+
+  /** Update alert */
+  async updateAlert(
+    req: UpdateAlertRequest,
+    options?: CallOptions
+  ): Promise<Alert> {
+    const url = `${this.host}/api/2.0/alerts/${req.alert?.id ?? ''}`;
+    const params = new URLSearchParams();
+    if (req.updateMask !== undefined) {
+      params.append('update_mask', req.updateMask.toString());
+    }
+    const query = params.toString();
+    const fullUrl = query !== '' ? `${url}?${query}` : url;
+    const body = marshalRequest(req.alert, marshalAlertSchema);
+    let resp: Alert | undefined;
+    const call: Call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers({'Content-Type': 'application/json'});
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest(
+        'PATCH',
+        fullUrl,
+        headers,
+        callSignal,
+        body
+      );
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(respBody, unmarshalAlertSchema);
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('API call completed without a result.');
+    }
+    return resp;
+  }
+}

package/src/v2/index.ts

@@ -0,0 +1,32 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+
+export {AlertsClient} from './client';
+
+export {
+  Aggregation,
+  AlertEvaluationState,
+  AlertLifecycleState,
+  ComparisonOperator,
+  SchedulePauseStatus,
+} from './model';
+
+export type {
+  Alert,
+  AlertEvaluation,
+  AlertNotification,
+  AlertOperand,
+  AlertOperandColumn,
+  AlertOperandValue,
+  AlertRunAs,
+  AlertSubscription,
+  CreateAlertRequest,
+  CronSchedule,
+  Empty,
+  GetAlertRequest,
+  ListAlertsRequest,
+  ListAlertsResponse,
+  TrashAlertRequest,
+  UpdateAlertRequest,
+} from './model';
+
+export {alertFieldMask} from './model';