bem-ai-sdk 0.0.4

package/src/core/pagination.ts

@@ -0,0 +1,512 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { BemError } from './error';
+import { FinalRequestOptions } from '../internal/request-options';
+import { defaultParseResponse } from '../internal/parse';
+import { type Bem } from '../client';
+import { APIPromise } from './api-promise';
+import { type APIResponseProps } from '../internal/parse';
+import { maybeObj } from '../internal/utils/values';
+
+export type PageRequestOptions = Pick<FinalRequestOptions, 'query' | 'headers' | 'body' | 'path' | 'method'>;
+
+export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
+  #client: Bem;
+  protected options: FinalRequestOptions;
+
+  protected response: Response;
+  protected body: unknown;
+
+  constructor(client: Bem, response: Response, body: unknown, options: FinalRequestOptions) {
+    this.#client = client;
+    this.options = options;
+    this.response = response;
+    this.body = body;
+  }
+
+  abstract nextPageRequestOptions(): PageRequestOptions | null;
+
+  abstract getPaginatedItems(): Item[];
+
+  hasNextPage(): boolean {
+    const items = this.getPaginatedItems();
+    if (!items.length) return false;
+    return this.nextPageRequestOptions() != null;
+  }
+
+  async getNextPage(): Promise<this> {
+    const nextOptions = this.nextPageRequestOptions();
+    if (!nextOptions) {
+      throw new BemError(
+        'No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.',
+      );
+    }
+
+    return await this.#client.requestAPIList(this.constructor as any, nextOptions);
+  }
+
+  async *iterPages(): AsyncGenerator<this> {
+    let page: this = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+
+  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+}
+
+/**
+ * This subclass of Promise will resolve to an instantiated Page once the request completes.
+ *
+ * It also implements AsyncIterable to allow auto-paginating iteration on an unawaited list call, eg:
+ *
+ *    for await (const item of client.items.list()) {
+ *      console.log(item)
+ *    }
+ */
+export class PagePromise<
+    PageClass extends AbstractPage<Item>,
+    Item = ReturnType<PageClass['getPaginatedItems']>[number],
+  >
+  extends APIPromise<PageClass>
+  implements AsyncIterable<Item>
+{
+  constructor(
+    client: Bem,
+    request: Promise<APIResponseProps>,
+    Page: new (...args: ConstructorParameters<typeof AbstractPage>) => PageClass,
+  ) {
+    super(
+      client,
+      request,
+      async (client, props) =>
+        new Page(client, props.response, await defaultParseResponse(client, props), props.options),
+    );
+  }
+
+  /**
+   * Allow auto-paginating iteration on an unawaited list call, eg:
+   *
+   *    for await (const item of client.items.list()) {
+   *      console.log(item)
+   *    }
+   */
+  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+}
+
+export interface FunctionsPageResponse<Item> {
+  functions: Array<Item>;
+}
+
+export interface FunctionsPageParams {
+  startingAfter?: string;
+
+  endingBefore?: string;
+
+  limit?: number;
+}
+
+export class FunctionsPage<Item extends { functionID: string }>
+  extends AbstractPage<Item>
+  implements FunctionsPageResponse<Item>
+{
+  functions: Array<Item>;
+
+  constructor(
+    client: Bem,
+    response: Response,
+    body: FunctionsPageResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.functions = body.functions || [];
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.functions ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const functions = this.getPaginatedItems();
+
+    const isForwards = !(
+      typeof this.options.query === 'object' && 'endingBefore' in (this.options.query || {})
+    );
+    if (isForwards) {
+      const functionID = functions[functions.length - 1]?.functionID;
+      if (!functionID) {
+        return null;
+      }
+
+      return {
+        ...this.options,
+        query: {
+          ...maybeObj(this.options.query),
+          startingAfter: functionID,
+        },
+      };
+    }
+
+    const functionID = functions[0]?.functionID;
+    if (!functionID) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        endingBefore: functionID,
+      },
+    };
+  }
+}
+
+export interface WorkflowsPageResponse<Item> {
+  workflows: Array<Item>;
+}
+
+export interface WorkflowsPageParams {
+  startingAfter?: string;
+
+  endingBefore?: string;
+
+  limit?: number;
+}
+
+export class WorkflowsPage<Item extends { id: string }>
+  extends AbstractPage<Item>
+  implements WorkflowsPageResponse<Item>
+{
+  workflows: Array<Item>;
+
+  constructor(
+    client: Bem,
+    response: Response,
+    body: WorkflowsPageResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.workflows = body.workflows || [];
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.workflows ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const workflows = this.getPaginatedItems();
+
+    const isForwards = !(
+      typeof this.options.query === 'object' && 'endingBefore' in (this.options.query || {})
+    );
+    if (isForwards) {
+      const id = workflows[workflows.length - 1]?.id;
+      if (!id) {
+        return null;
+      }
+
+      return {
+        ...this.options,
+        query: {
+          ...maybeObj(this.options.query),
+          startingAfter: id,
+        },
+      };
+    }
+
+    const id = workflows[0]?.id;
+    if (!id) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        endingBefore: id,
+      },
+    };
+  }
+}
+
+export interface CallsPageResponse<Item> {
+  calls: Array<Item>;
+}
+
+export interface CallsPageParams {
+  startingAfter?: string;
+
+  endingBefore?: string;
+
+  limit?: number;
+}
+
+export class CallsPage<Item extends { callID: string }>
+  extends AbstractPage<Item>
+  implements CallsPageResponse<Item>
+{
+  calls: Array<Item>;
+
+  constructor(client: Bem, response: Response, body: CallsPageResponse<Item>, options: FinalRequestOptions) {
+    super(client, response, body, options);
+
+    this.calls = body.calls || [];
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.calls ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const calls = this.getPaginatedItems();
+
+    const isForwards = !(
+      typeof this.options.query === 'object' && 'endingBefore' in (this.options.query || {})
+    );
+    if (isForwards) {
+      const callID = calls[calls.length - 1]?.callID;
+      if (!callID) {
+        return null;
+      }
+
+      return {
+        ...this.options,
+        query: {
+          ...maybeObj(this.options.query),
+          startingAfter: callID,
+        },
+      };
+    }
+
+    const callID = calls[0]?.callID;
+    if (!callID) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        endingBefore: callID,
+      },
+    };
+  }
+}
+
+export interface OutputsPageResponse<Item> {
+  outputs: Array<Item>;
+}
+
+export interface OutputsPageParams {
+  startingAfter?: string;
+
+  endingBefore?: string;
+
+  limit?: number;
+}
+
+export class OutputsPage<Item extends { eventID: string }>
+  extends AbstractPage<Item>
+  implements OutputsPageResponse<Item>
+{
+  outputs: Array<Item>;
+
+  constructor(
+    client: Bem,
+    response: Response,
+    body: OutputsPageResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.outputs = body.outputs || [];
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.outputs ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const outputs = this.getPaginatedItems();
+
+    const isForwards = !(
+      typeof this.options.query === 'object' && 'endingBefore' in (this.options.query || {})
+    );
+    if (isForwards) {
+      const eventID = outputs[outputs.length - 1]?.eventID;
+      if (!eventID) {
+        return null;
+      }
+
+      return {
+        ...this.options,
+        query: {
+          ...maybeObj(this.options.query),
+          startingAfter: eventID,
+        },
+      };
+    }
+
+    const eventID = outputs[0]?.eventID;
+    if (!eventID) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        endingBefore: eventID,
+      },
+    };
+  }
+}
+
+export interface ErrorsPageResponse<Item> {
+  errors: Array<Item>;
+}
+
+export interface ErrorsPageParams {
+  startingAfter?: string;
+
+  endingBefore?: string;
+
+  limit?: number;
+}
+
+export class ErrorsPage<Item extends { eventID: string }>
+  extends AbstractPage<Item>
+  implements ErrorsPageResponse<Item>
+{
+  errors: Array<Item>;
+
+  constructor(client: Bem, response: Response, body: ErrorsPageResponse<Item>, options: FinalRequestOptions) {
+    super(client, response, body, options);
+
+    this.errors = body.errors || [];
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.errors ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const errors = this.getPaginatedItems();
+
+    const isForwards = !(
+      typeof this.options.query === 'object' && 'endingBefore' in (this.options.query || {})
+    );
+    if (isForwards) {
+      const eventID = errors[errors.length - 1]?.eventID;
+      if (!eventID) {
+        return null;
+      }
+
+      return {
+        ...this.options,
+        query: {
+          ...maybeObj(this.options.query),
+          startingAfter: eventID,
+        },
+      };
+    }
+
+    const eventID = errors[0]?.eventID;
+    if (!eventID) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        endingBefore: eventID,
+      },
+    };
+  }
+}
+
+export interface WorkflowVersionsPageResponse<Item> {
+  versions: Array<Item>;
+}
+
+export interface WorkflowVersionsPageParams {
+  startingAfter?: number;
+
+  endingBefore?: number;
+
+  limit?: number;
+}
+
+export class WorkflowVersionsPage<Item extends { versionNum: number }>
+  extends AbstractPage<Item>
+  implements WorkflowVersionsPageResponse<Item>
+{
+  versions: Array<Item>;
+
+  constructor(
+    client: Bem,
+    response: Response,
+    body: WorkflowVersionsPageResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.versions = body.versions || [];
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.versions ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const versions = this.getPaginatedItems();
+
+    const isForwards = !(
+      typeof this.options.query === 'object' && 'endingBefore' in (this.options.query || {})
+    );
+    if (isForwards) {
+      const versionNum = versions[versions.length - 1]?.versionNum;
+      if (!versionNum) {
+        return null;
+      }
+
+      return {
+        ...this.options,
+        query: {
+          ...maybeObj(this.options.query),
+          startingAfter: versionNum,
+        },
+      };
+    }
+
+    const versionNum = versions[0]?.versionNum;
+    if (!versionNum) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        endingBefore: versionNum,
+      },
+    };
+  }
+}

package/src/core/resource.ts

@@ -0,0 +1,11 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { Bem } from '../client';
+
+export abstract class APIResource {
+  protected _client: Bem;
+
+  constructor(client: Bem) {
+    this._client = client;
+  }
+}

package/src/core/uploads.ts

@@ -0,0 +1,2 @@
+export { type Uploadable } from '../internal/uploads';
+export { toFile, type ToFileInput } from '../internal/to-file';

package/src/error.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/error instead */
+export * from './core/error';

package/src/index.ts

@@ -0,0 +1,23 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Bem as default } from './client';
+
+export { type Uploadable, toFile } from './core/uploads';
+export { APIPromise } from './core/api-promise';
+export { Bem, type ClientOptions } from './client';
+export { PagePromise } from './core/pagination';
+export {
+  BemError,
+  APIError,
+  APIConnectionError,
+  APIConnectionTimeoutError,
+  APIUserAbortError,
+  NotFoundError,
+  ConflictError,
+  RateLimitError,
+  BadRequestError,
+  AuthenticationError,
+  InternalServerError,
+  PermissionDeniedError,
+  UnprocessableEntityError,
+} from './core/error';

package/src/internal/README.md

@@ -0,0 +1,3 @@
+# `internal`
+
+The modules in this directory are not importable outside this package and will change between releases.

package/src/internal/builtin-types.ts

@@ -0,0 +1,93 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+/**
+ * An alias to the builtin `RequestInit` type so we can
+ * easily alias it in import statements if there are name clashes.
+ *
+ * https://developer.mozilla.org/docs/Web/API/RequestInit
+ */
+type _RequestInit = RequestInit;
+
+/**
+ * An alias to the builtin `Response` type so we can
+ * easily alias it in import statements if there are name clashes.
+ *
+ * https://developer.mozilla.org/docs/Web/API/Response
+ */
+type _Response = Response;
+
+/**
+ * The type for the first argument to `fetch`.
+ *
+ * https://developer.mozilla.org/docs/Web/API/Window/fetch#resource
+ */
+type _RequestInfo = Request | URL | string;
+
+/**
+ * The type for constructing `RequestInit` Headers.
+ *
+ * https://developer.mozilla.org/docs/Web/API/RequestInit#setting_headers
+ */
+type _HeadersInit = RequestInit['headers'];
+
+/**
+ * The type for constructing `RequestInit` body.
+ *
+ * https://developer.mozilla.org/docs/Web/API/RequestInit#body
+ */
+type _BodyInit = RequestInit['body'];
+
+/**
+ * An alias to the builtin `Array<T>` type so we can
+ * easily alias it in import statements if there are name clashes.
+ */
+type _Array<T> = Array<T>;
+
+/**
+ * An alias to the builtin `Record<K, T>` type so we can
+ * easily alias it in import statements if there are name clashes.
+ */
+type _Record<K extends keyof any, T> = Record<K, T>;
+
+export type {
+  _Array as Array,
+  _BodyInit as BodyInit,
+  _HeadersInit as HeadersInit,
+  _Record as Record,
+  _RequestInfo as RequestInfo,
+  _RequestInit as RequestInit,
+  _Response as Response,
+};
+
+/**
+ * A copy of the builtin `EndingType` type as it isn't fully supported in certain
+ * environments and attempting to reference the global version will error.
+ *
+ * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L27941
+ */
+type EndingType = 'native' | 'transparent';
+
+/**
+ * A copy of the builtin `BlobPropertyBag` type as it isn't fully supported in certain
+ * environments and attempting to reference the global version will error.
+ *
+ * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L154
+ * https://developer.mozilla.org/en-US/docs/Web/API/Blob/Blob#options
+ */
+export interface BlobPropertyBag {
+  endings?: EndingType;
+  type?: string;
+}
+
+/**
+ * A copy of the builtin `FilePropertyBag` type as it isn't fully supported in certain
+ * environments and attempting to reference the global version will error.
+ *
+ * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L503
+ * https://developer.mozilla.org/en-US/docs/Web/API/File/File#options
+ */
+export interface FilePropertyBag extends BlobPropertyBag {
+  lastModified?: number;
+}