@scenario-labs/sdk 0.3.0 → 1.1.0

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;
+  }
+}

package/src/index.ts

@@ -6,6 +6,7 @@ export { type Uploadable, toFile } from './core/uploads';
 export { APIPromise } from './core/api-promise';
 export { Scenario } from './lib/scenario';
 export { type ClientOptions } from './client';
+export { PagePromise } from './core/pagination';
 export {
   ScenarioError,
   APIError,
@@ -21,8 +22,17 @@ export {
   PermissionDeniedError,
   UnprocessableEntityError,
 } from './core/error';
-export { Job, type WaitOptions, type WithJob } from './lib/job';
+export { EnhancedJobs, Job, type WaitOptions, type WithJob } from './lib/job';
 export { EnhancedWorkflows, WorkflowEntity } from './lib/workflow';
 export { validateWorkflowFlow } from './lib/workflow_validator';
+export {
+  validateEditorInfo,
+  WorkflowImportError,
+  VALID_EDITOR_NODE_TYPES,
+  type WorkflowExportData,
+  type WorkflowEditorNodeType,
+} from './lib/workflow_import_validator';
 export { EnhancedGenerate } from './lib/generate';
 export { EnhancedModels, EnhancedTrain } from './lib/models';
+export { EnhancedUploads, Upload, type UploadWaitOptions, type WithUpload } from './lib/upload';
+export { EnhancedAssets, Asset, type WithAsset } from './lib/asset';

package/src/lib/asset.ts

@@ -0,0 +1,85 @@
+import type { APIPromise } from '../core/api-promise';
+import type { RequestOptions } from '../internal/request-options';
+import {
+  Assets,
+  type AssetRetrieveParams,
+  type AssetRetrieveResponse,
+  type AssetUpdateParams,
+  type AssetUpdateResponse,
+} from '../resources/assets/assets';
+
+/** Asset methods added on top of the original asset fields. */
+export class AssetMethods {
+  /**
+   * Fetch the asset's content as bytes, using the signed `url` field on the
+   * asset. Works in Node ≥18 and in browsers with no extra setup.
+   *
+   * This is a thin wrapper around `fetch(asset.url)` — use `asset.url`
+   * directly if you need streaming or a Response object.
+   *
+   * @example
+   * ```ts
+   * const res = await client.assets.retrieve(assetId);
+   * const bytes = await res.asset.download();
+   * await fs.writeFile('out.png', bytes);
+   * ```
+   */
+  async download(this: Asset): Promise<Uint8Array> {
+    const res = await fetch(this.url);
+    if (!res.ok) {
+      throw new Error(`Failed to download asset ${this.id}: ${res.status} ${res.statusText}`);
+    }
+    return new Uint8Array(await res.arrayBuffer());
+  }
+
+  /** @internal Create an Asset from raw asset data. */
+  static from(data: AssetRetrieveResponse['asset']): Asset {
+    return Object.assign(Object.create(AssetMethods.prototype), data) as Asset;
+  }
+}
+
+/** An asset with all original fields plus `.download()`. */
+export type Asset = AssetRetrieveResponse.Asset & AssetMethods;
+export const Asset = AssetMethods;
+
+/**
+ * @internal Helper type: adds `.download()` to the `asset` field of a response.
+ * Uses intersection so the original response type is preserved — a `WithAsset<T>` is still assignable to `T`.
+ */
+export type WithAsset<T extends { asset: unknown }> = T & { asset: AssetMethods };
+
+/**
+ * @internal Wrap `_thenUnwrap` to replace `response.asset` with an enhanced Asset.
+ */
+export function enhanceAsset<T extends { asset: { id: string; url: string } }>(
+  promise: APIPromise<T>,
+): APIPromise<WithAsset<T>> {
+  return promise._thenUnwrap((data) => ({
+    ...data,
+    asset: Asset.from(data.asset as AssetRetrieveResponse['asset']),
+  }));
+}
+
+/**
+ * Enhanced Assets resource.
+ * All original methods (and subresources like `download`, `public`) are
+ * inherited. `retrieve` and `update` responses' `asset` field gains a
+ * `.download()` helper for fetching the asset's bytes.
+ */
+export class EnhancedAssets extends Assets {
+  override retrieve(
+    assetID: string,
+    query: AssetRetrieveParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<WithAsset<AssetRetrieveResponse>> {
+    return enhanceAsset(super.retrieve(assetID, query, options));
+  }
+
+  override update(
+    assetID: string,
+    params: AssetUpdateParams,
+    options?: RequestOptions,
+  ): APIPromise<WithAsset<AssetUpdateResponse>> {
+    return enhanceAsset(super.update(assetID, params, options));
+  }
+}

package/src/lib/job.ts

@@ -1,6 +1,12 @@
 import type { Scenario } from '../client';
 import type { APIPromise } from '../core/api-promise';
-import type { JobRetrieveResponse } from '../resources/jobs';
+import type { RequestOptions } from '../internal/request-options';
+import {
+  Jobs,
+  type JobRetrieveResponse,
+  type JobTriggerActionParams,
+  type JobTriggerActionResponse,
+} from '../resources/jobs';
 
 export interface WaitOptions {
   /** Polling interval in milliseconds. Default: 3000 */
@@ -76,3 +82,24 @@ export function enhanceJob<T extends { job: { jobId: string; status: string } }>
     job: Job.from(client, data.job as JobRetrieveResponse['job']),
   }));
 }
+
+/**
+ * Enhanced Jobs resource. `retrieve` and `triggerAction` responses' `job`
+ * field gains a `.wait()` helper — previously only job-creating endpoints
+ * (workflow.run, models.trigger, generate.*) had it. `list` is not enhanced:
+ * its items use a different (but structurally similar) type, and users
+ * typically fetch individual jobs via `retrieve` before acting on them.
+ */
+export class EnhancedJobs extends Jobs {
+  override retrieve(jobID: string, options?: RequestOptions): APIPromise<WithJob<JobRetrieveResponse>> {
+    return enhanceJob(this._client, super.retrieve(jobID, options));
+  }
+
+  override triggerAction(
+    jobID: string,
+    params: JobTriggerActionParams,
+    options?: RequestOptions,
+  ): APIPromise<WithJob<JobTriggerActionResponse>> {
+    return enhanceJob(this._client, super.triggerAction(jobID, params, options));
+  }
+}