Class Replicate

integrations/replicate/src/index.ts:28–210

export type ReplicateRunTask = InstanceType<typeof Replicate>["runTask"];

export class Replicate implements TriggerIntegration {
  private _options: ReplicateIntegrationOptions;
  private _client?: any;
  private _io?: IO;
  private _connectionKey?: string;

  constructor(private options: ReplicateIntegrationOptions) {
    if (Object.keys(options).includes("apiKey") && !options.apiKey) {
      throw `Can't create Replicate integration (${options.id}) as apiKey was undefined`;
    }

    this._options = options;
  }

  get authSource() {
    return "LOCAL" as const;
  }

  get id() {
    return this.options.id;
  }

  get metadata() {
    return { id: "replicate", name: "Replicate" };
  }

  cloneForRun(io: IO, connectionKey: string, auth?: ConnectionAuth) {
    const replicate = new Replicate(this._options);
    replicate._io = io;
    replicate._connectionKey = connectionKey;
    replicate._client = this.createClient(auth);
    return replicate;
  }

  createClient(auth?: ConnectionAuth) {
    return new ReplicateClient({
      auth: this._options.apiKey,
    });
  }

  runTask<T, TResult extends Json<T> | void>(
    key: IntegrationTaskKey,
    callback: (client: ReplicateClient, task: IOTask, io: IO) => Promise<TResult>,
    options?: RunTaskOptions,
    errorCallback?: RunTaskErrorCallback
  ): Promise<TResult> {
    if (!this._io) throw new Error("No IO");
    if (!this._connectionKey) throw new Error("No connection key");

    return this._io.runTask(
      key,
      (task, io) => {
        if (!this._client) throw new Error("No client");
        return callback(this._client, task, io);
      },
      {
        icon: "replicate",
        retry: retry.standardBackoff,