@scenario-labs/sdk 0.3.0 → 1.0.0

package/src/client.ts

@@ -14,6 +14,26 @@ import * as Opts from './internal/request-options';
 import { stringifyQuery } from './internal/utils/query';
 import { VERSION } from './version';
 import * as Errors from './core/error';
+import * as Pagination from './core/pagination';
+import {
+  AbstractPage,
+  type AssetsCursorParams,
+  AssetsCursorResponse,
+  type CollectionsCursorParams,
+  CollectionsCursorResponse,
+  type JobsCursorParams,
+  JobsCursorResponse,
+  type ModelsCursorParams,
+  ModelsCursorResponse,
+  type SearchHitsOffsetParams,
+  SearchHitsOffsetResponse,
+  type SnapshotsCursorParams,
+  SnapshotsCursorResponse,
+  type TagsCursorParams,
+  TagsCursorResponse,
+  type WorkflowsCursorParams,
+  WorkflowsCursorResponse,
+} from './core/pagination';
 import * as Uploads from './core/uploads';
 import * as API from './resources/index';
 import { APIPromise } from './core/api-promise';
@@ -37,6 +57,7 @@ import {
 import {
   JobListParams,
   JobListResponse,
+  JobListResponsesJobsCursor,
   JobRetrieveResponse,
   JobTriggerActionParams,
   JobTriggerActionResponse,
@@ -47,10 +68,12 @@ import {
   Search,
   SearchAssetSearchParams,
   SearchAssetSearchResponse,
+  SearchAssetSearchResponsesSearchHitsOffset,
   SearchModelSearchParams,
   SearchModelSearchResponse,
+  SearchModelSearchResponsesSearchHitsOffset,
 } from './resources/search';
-import { TagListParams, TagListResponse, Tags } from './resources/tags';
+import { TagListParams, TagListResponse, TagListResponsesTagsCursor, Tags } from './resources/tags';
 import {
   UploadCreateParams,
   UploadCreateResponse,
@@ -70,6 +93,7 @@ import {
   WorkflowGetTagsResponse,
   WorkflowListParams,
   WorkflowListResponse,
+  WorkflowListResponsesWorkflowsCursor,
   WorkflowRetrieveResponse,
   WorkflowRunParams,
   WorkflowRunResponse,
@@ -86,8 +110,10 @@ import {
   AssetGetBulkResponse,
   AssetListParams,
   AssetListResponse,
+  AssetListResponsesAssetsCursor,
   AssetListSnapshotsParams,
   AssetListSnapshotsResponse,
+  AssetListSnapshotsResponsesSnapshotsCursor,
   AssetLockParams,
   AssetLockResponse,
   AssetRetrieveParams,
@@ -108,6 +134,7 @@ import {
   CollectionDeleteResponse,
   CollectionListParams,
   CollectionListResponse,
+  CollectionListResponsesCollectionsCursor,
   CollectionRetrieveResponse,
   CollectionUpdateParams,
   CollectionUpdateResponse,
@@ -127,6 +154,7 @@ import {
   ModelGetBulkResponse,
   ModelListParams,
   ModelListResponse,
+  ModelListResponsesModelsCursor,
   ModelRetrieveParams,
   ModelRetrieveResponse,
   ModelTransferParams,
@@ -647,6 +675,30 @@ export class Scenario {
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
   }
 
+  getAPIList<Item, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(
+    path: string,
+    Page: new (...args: any[]) => PageClass,
+    opts?: PromiseOrValue<RequestOptions>,
+  ): Pagination.PagePromise<PageClass, Item> {
+    return this.requestAPIList(
+      Page,
+      opts && 'then' in opts ?
+        opts.then((opts) => ({ method: 'get', path, ...opts }))
+      : { method: 'get', path, ...opts },
+    );
+  }
+
+  requestAPIList<
+    Item = unknown,
+    PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>,
+  >(
+    Page: new (...args: ConstructorParameters<typeof Pagination.AbstractPage>) => PageClass,
+    options: PromiseOrValue<FinalRequestOptions>,
+  ): Pagination.PagePromise<PageClass, Item> {
+    const request = this.makeRequest(options, null, undefined);
+    return new Pagination.PagePromise<PageClass, Item>(this as any as Scenario, request, Page);
+  }
+
   async fetchWithTimeout(
     url: RequestInfo,
     init: RequestInit | undefined,
@@ -922,6 +974,42 @@ Scenario.Workflows = Workflows;
 export declare namespace Scenario {
   export type RequestOptions = Opts.RequestOptions;
 
+  export import AssetsCursor = Pagination.AssetsCursor;
+  export { type AssetsCursorParams as AssetsCursorParams, type AssetsCursorResponse as AssetsCursorResponse };
+
+  export import SnapshotsCursor = Pagination.SnapshotsCursor;
+  export {
+    type SnapshotsCursorParams as SnapshotsCursorParams,
+    type SnapshotsCursorResponse as SnapshotsCursorResponse,
+  };
+
+  export import CollectionsCursor = Pagination.CollectionsCursor;
+  export {
+    type CollectionsCursorParams as CollectionsCursorParams,
+    type CollectionsCursorResponse as CollectionsCursorResponse,
+  };
+
+  export import JobsCursor = Pagination.JobsCursor;
+  export { type JobsCursorParams as JobsCursorParams, type JobsCursorResponse as JobsCursorResponse };
+
+  export import ModelsCursor = Pagination.ModelsCursor;
+  export { type ModelsCursorParams as ModelsCursorParams, type ModelsCursorResponse as ModelsCursorResponse };
+
+  export import TagsCursor = Pagination.TagsCursor;
+  export { type TagsCursorParams as TagsCursorParams, type TagsCursorResponse as TagsCursorResponse };
+
+  export import WorkflowsCursor = Pagination.WorkflowsCursor;
+  export {
+    type WorkflowsCursorParams as WorkflowsCursorParams,
+    type WorkflowsCursorResponse as WorkflowsCursorResponse,
+  };
+
+  export import SearchHitsOffset = Pagination.SearchHitsOffset;
+  export {
+    type SearchHitsOffsetParams as SearchHitsOffsetParams,
+    type SearchHitsOffsetResponse as SearchHitsOffsetResponse,
+  };
+
   export {
     Assets as Assets,
     type AssetRetrieveResponse as AssetRetrieveResponse,
@@ -935,6 +1023,8 @@ export declare namespace Scenario {
     type AssetUnlockResponse as AssetUnlockResponse,
     type AssetUpdateTagsResponse as AssetUpdateTagsResponse,
     type AssetUploadResponse as AssetUploadResponse,
+    type AssetListResponsesAssetsCursor as AssetListResponsesAssetsCursor,
+    type AssetListSnapshotsResponsesSnapshotsCursor as AssetListSnapshotsResponsesSnapshotsCursor,
     type AssetRetrieveParams as AssetRetrieveParams,
     type AssetUpdateParams as AssetUpdateParams,
     type AssetListParams as AssetListParams,
@@ -955,6 +1045,7 @@ export declare namespace Scenario {
     type CollectionUpdateResponse as CollectionUpdateResponse,
     type CollectionListResponse as CollectionListResponse,
     type CollectionDeleteResponse as CollectionDeleteResponse,
+    type CollectionListResponsesCollectionsCursor as CollectionListResponsesCollectionsCursor,
     type CollectionCreateParams as CollectionCreateParams,
     type CollectionUpdateParams as CollectionUpdateParams,
     type CollectionListParams as CollectionListParams,
@@ -983,6 +1074,7 @@ export declare namespace Scenario {
     type JobRetrieveResponse as JobRetrieveResponse,
     type JobListResponse as JobListResponse,
     type JobTriggerActionResponse as JobTriggerActionResponse,
+    type JobListResponsesJobsCursor as JobListResponsesJobsCursor,
     type JobListParams as JobListParams,
     type JobTriggerActionParams as JobTriggerActionParams,
   };
@@ -1000,6 +1092,7 @@ export declare namespace Scenario {
     type ModelGetBulkResponse as ModelGetBulkResponse,
     type ModelTransferResponse as ModelTransferResponse,
     type ModelUpdateTagsResponse as ModelUpdateTagsResponse,
+    type ModelListResponsesModelsCursor as ModelListResponsesModelsCursor,
     type ModelCreateParams as ModelCreateParams,
     type ModelRetrieveParams as ModelRetrieveParams,
     type ModelUpdateParams as ModelUpdateParams,
@@ -1018,11 +1111,18 @@ export declare namespace Scenario {
     Search as Search,
     type SearchAssetSearchResponse as SearchAssetSearchResponse,
     type SearchModelSearchResponse as SearchModelSearchResponse,
+    type SearchAssetSearchResponsesSearchHitsOffset as SearchAssetSearchResponsesSearchHitsOffset,
+    type SearchModelSearchResponsesSearchHitsOffset as SearchModelSearchResponsesSearchHitsOffset,
     type SearchAssetSearchParams as SearchAssetSearchParams,
     type SearchModelSearchParams as SearchModelSearchParams,
   };
 
-  export { Tags as Tags, type TagListResponse as TagListResponse, type TagListParams as TagListParams };
+  export {
+    Tags as Tags,
+    type TagListResponse as TagListResponse,
+    type TagListResponsesTagsCursor as TagListResponsesTagsCursor,
+    type TagListParams as TagListParams,
+  };
 
   export {
     UploadsAPIUploads as Uploads,
@@ -1049,6 +1149,7 @@ export declare namespace Scenario {
     type WorkflowApproveUserResponse as WorkflowApproveUserResponse,
     type WorkflowGetTagsResponse as WorkflowGetTagsResponse,
     type WorkflowRunResponse as WorkflowRunResponse,
+    type WorkflowListResponsesWorkflowsCursor as WorkflowListResponsesWorkflowsCursor,
     type WorkflowCreateParams as WorkflowCreateParams,
     type WorkflowUpdateParams as WorkflowUpdateParams,
     type WorkflowListParams as WorkflowListParams,

package/src/core/pagination.ts

@@ -0,0 +1,497 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { ScenarioError } from './error';
+import { FinalRequestOptions } from '../internal/request-options';
+import { defaultParseResponse } from '../internal/parse';
+import { type Scenario } 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: Scenario;
+  protected options: FinalRequestOptions;
+
+  protected response: Response;
+  protected body: unknown;
+
+  constructor(client: Scenario, 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 ScenarioError(
+        '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: Scenario,
+    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 AssetsCursorResponse<Item> {
+  assets: Array<Item>;
+
+  nextPaginationToken: string;
+}
+
+export interface AssetsCursorParams {
+  paginationToken?: string;
+}
+
+export class AssetsCursor<Item> extends AbstractPage<Item> implements AssetsCursorResponse<Item> {
+  assets: Array<Item>;
+
+  nextPaginationToken: string;
+
+  constructor(
+    client: Scenario,
+    response: Response,
+    body: AssetsCursorResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.assets = body.assets || [];
+    this.nextPaginationToken = body.nextPaginationToken || '';
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.assets ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const cursor = this.nextPaginationToken;
+    if (!cursor) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        paginationToken: cursor,
+      },
+    };
+  }
+}
+
+export interface SnapshotsCursorResponse<Item> {
+  snapshots: Array<Item>;
+
+  nextPaginationToken: string;
+}
+
+export interface SnapshotsCursorParams {
+  paginationToken?: string;
+}
+
+export class SnapshotsCursor<Item> extends AbstractPage<Item> implements SnapshotsCursorResponse<Item> {
+  snapshots: Array<Item>;
+
+  nextPaginationToken: string;
+
+  constructor(
+    client: Scenario,
+    response: Response,
+    body: SnapshotsCursorResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.snapshots = body.snapshots || [];
+    this.nextPaginationToken = body.nextPaginationToken || '';
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.snapshots ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const cursor = this.nextPaginationToken;
+    if (!cursor) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        paginationToken: cursor,
+      },
+    };
+  }
+}
+
+export interface CollectionsCursorResponse<Item> {
+  collections: Array<Item>;
+
+  nextPaginationToken: string;
+}
+
+export interface CollectionsCursorParams {
+  paginationToken?: string;
+}
+
+export class CollectionsCursor<Item> extends AbstractPage<Item> implements CollectionsCursorResponse<Item> {
+  collections: Array<Item>;
+
+  nextPaginationToken: string;
+
+  constructor(
+    client: Scenario,
+    response: Response,
+    body: CollectionsCursorResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.collections = body.collections || [];
+    this.nextPaginationToken = body.nextPaginationToken || '';
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.collections ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const cursor = this.nextPaginationToken;
+    if (!cursor) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        paginationToken: cursor,
+      },
+    };
+  }
+}
+
+export interface JobsCursorResponse<Item> {
+  jobs: Array<Item>;
+
+  nextPaginationToken: string;
+}
+
+export interface JobsCursorParams {
+  paginationToken?: string;
+}
+
+export class JobsCursor<Item> extends AbstractPage<Item> implements JobsCursorResponse<Item> {
+  jobs: Array<Item>;
+
+  nextPaginationToken: string;
+
+  constructor(
+    client: Scenario,
+    response: Response,
+    body: JobsCursorResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.jobs = body.jobs || [];
+    this.nextPaginationToken = body.nextPaginationToken || '';
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.jobs ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const cursor = this.nextPaginationToken;
+    if (!cursor) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        paginationToken: cursor,
+      },
+    };
+  }
+}
+
+export interface ModelsCursorResponse<Item> {
+  models: Array<Item>;
+
+  nextPaginationToken: string;
+}
+
+export interface ModelsCursorParams {
+  paginationToken?: string;
+}
+
+export class ModelsCursor<Item> extends AbstractPage<Item> implements ModelsCursorResponse<Item> {
+  models: Array<Item>;
+
+  nextPaginationToken: string;
+
+  constructor(
+    client: Scenario,
+    response: Response,
+    body: ModelsCursorResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.models = body.models || [];
+    this.nextPaginationToken = body.nextPaginationToken || '';
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.models ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const cursor = this.nextPaginationToken;
+    if (!cursor) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        paginationToken: cursor,
+      },
+    };
+  }
+}
+
+export interface TagsCursorResponse<Item> {
+  tags: Array<Item>;
+
+  nextPaginationToken: string;
+}
+
+export interface TagsCursorParams {
+  paginationToken?: string;
+}
+
+export class TagsCursor<Item> extends AbstractPage<Item> implements TagsCursorResponse<Item> {
+  tags: Array<Item>;
+
+  nextPaginationToken: string;
+
+  constructor(
+    client: Scenario,
+    response: Response,
+    body: TagsCursorResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.tags = body.tags || [];
+    this.nextPaginationToken = body.nextPaginationToken || '';
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.tags ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const cursor = this.nextPaginationToken;
+    if (!cursor) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        paginationToken: cursor,
+      },
+    };
+  }
+}
+
+export interface WorkflowsCursorResponse<Item> {
+  workflows: Array<Item>;
+
+  nextPaginationToken: string;
+}
+
+export interface WorkflowsCursorParams {
+  paginationToken?: string;
+}
+
+export class WorkflowsCursor<Item> extends AbstractPage<Item> implements WorkflowsCursorResponse<Item> {
+  workflows: Array<Item>;
+
+  nextPaginationToken: string;
+
+  constructor(
+    client: Scenario,
+    response: Response,
+    body: WorkflowsCursorResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.workflows = body.workflows || [];
+    this.nextPaginationToken = body.nextPaginationToken || '';
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.workflows ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const cursor = this.nextPaginationToken;
+    if (!cursor) {
+      return null;
+    }
+
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        paginationToken: cursor,
+      },
+    };
+  }
+}
+
+export interface SearchHitsOffsetResponse<Item> {
+  hits: Array<Item>;
+
+  estimatedTotalHits: number;
+
+  offset: number;
+}
+
+export interface SearchHitsOffsetParams {
+  offset?: number;
+}
+
+export class SearchHitsOffset<Item> extends AbstractPage<Item> implements SearchHitsOffsetResponse<Item> {
+  hits: Array<Item>;
+
+  estimatedTotalHits: number;
+
+  offset: number;
+
+  constructor(
+    client: Scenario,
+    response: Response,
+    body: SearchHitsOffsetResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.hits = body.hits || [];
+    this.estimatedTotalHits = body.estimatedTotalHits || 0;
+    this.offset = body.offset || 0;
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.hits ?? [];
+  }
+
+  nextPageRequestOptions(): PageRequestOptions | null {
+    const offset = this.offset ?? 0;
+    const length = this.getPaginatedItems().length;
+    const currentCount = offset + length;
+
+    const totalCount = this.estimatedTotalHits;
+    if (!totalCount) {
+      return null;
+    }
+
+    if (currentCount < totalCount) {
+      return {
+        ...this.options,
+        body: {
+          ...maybeObj(this.options.body),
+          offset: currentCount,
+        },
+      };
+    }
+
+    return null;
+  }
+}