@aws/nx-plugin 0.14.2 → 0.15.0

package/src/open-api/ts-hooks/__snapshots__/generator.spec.tsx.snap

@@ -0,0 +1,1092 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`openApiTsHooksGenerator > should generate an options proxy for a mutation operation 1`] = `
+"import type { UseMutationOptions } from '@tanstack/react-query';
+import type {
+  CreateUserRequest,
+  CreateUserError,
+  CreateUser201Response,
+} from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._createUserMutationKey = this._createUserMutationKey.bind(this);
+    this._createUserMutationOptions =
+      this._createUserMutationOptions.bind(this);
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _createUserMutationKey() {
+    return [...this.queryKey(), 'createUser'];
+  }
+  private _createUserMutationOptions(
+    options?: UseMutationOptions<
+      CreateUser201Response,
+      CreateUserError,
+      CreateUserRequest
+    >,
+  ): UseMutationOptions<
+    CreateUser201Response,
+    CreateUserError,
+    CreateUserRequest
+  > {
+    return {
+      mutationFn: (input) => this.$client.createUser(input),
+      mutationKey: this._createUserMutationKey(),
+      ...options,
+    };
+  }
+
+  public createUser = {
+    mutationKey: this._createUserMutationKey.bind(this),
+    mutationOptions: this._createUserMutationOptions.bind(this),
+  };
+}
+"
+`;
+
+exports[`openApiTsHooksGenerator > should generate an options proxy for a query operation 1`] = `
+"import type { QueryFilters, UseQueryOptions } from '@tanstack/react-query';
+import type { GetTestError, GetTest200Response } from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._getTestQueryKey = this._getTestQueryKey.bind(this);
+    this._getTestQueryOptions = this._getTestQueryOptions.bind(this);
+    this._getTestQueryFilter = this._getTestQueryFilter.bind(this);
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _getTestQueryKey() {
+    return [...this.queryKey(), 'getTest'];
+  }
+  private _getTestQueryOptions(
+    options?: Omit<
+      UseQueryOptions<GetTest200Response, GetTestError>,
+      'queryFn' | 'queryKey'
+    > &
+      Partial<
+        Pick<
+          UseQueryOptions<GetTest200Response, GetTestError>,
+          'queryFn' | 'queryKey'
+        >
+      >,
+  ): UseQueryOptions<GetTest200Response, GetTestError> {
+    return {
+      queryFn: () => this.$client.getTest(),
+      queryKey: this._getTestQueryKey(),
+      ...options,
+    };
+  }
+  private _getTestQueryFilter(
+    filter?: QueryFilters<GetTest200Response, GetTestError>,
+  ): QueryFilters<GetTest200Response, GetTestError> {
+    return {
+      queryKey: this._getTestQueryKey(),
+      ...filter,
+    };
+  }
+
+  public getTest = {
+    queryKey: this._getTestQueryKey.bind(this),
+    queryOptions: this._getTestQueryOptions.bind(this),
+    queryFilter: this._getTestQueryFilter.bind(this),
+  };
+}
+"
+`;
+
+exports[`openApiTsHooksGenerator > should generate an options proxy for a successful infinite query operation 1`] = `
+"import type {
+  QueryFilters,
+  UseQueryOptions,
+  UseInfiniteQueryOptions,
+  InfiniteData,
+} from '@tanstack/react-query';
+import type {
+  GetItemsRequest,
+  GetItemsError,
+  GetItems200Response,
+} from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._getItemsQueryKey = this._getItemsQueryKey.bind(this);
+    this._getItemsQueryOptions = this._getItemsQueryOptions.bind(this);
+    this._getItemsQueryFilter = this._getItemsQueryFilter.bind(this);
+    this._getItemsInfiniteQueryOptions =
+      this._getItemsInfiniteQueryOptions.bind(this);
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _getItemsQueryKey(input: GetItemsRequest) {
+    return [...this.queryKey(), 'getItems', input];
+  }
+  private _getItemsQueryOptions(
+    input: GetItemsRequest,
+    options?: Omit<
+      UseQueryOptions<GetItems200Response, GetItemsError>,
+      'queryFn' | 'queryKey'
+    > &
+      Partial<
+        Pick<
+          UseQueryOptions<GetItems200Response, GetItemsError>,
+          'queryFn' | 'queryKey'
+        >
+      >,
+  ): UseQueryOptions<GetItems200Response, GetItemsError> {
+    return {
+      queryFn: () => this.$client.getItems(input),
+      queryKey: this._getItemsQueryKey(input),
+      ...options,
+    };
+  }
+  private _getItemsQueryFilter(
+    input: GetItemsRequest,
+    filter?: QueryFilters<GetItems200Response, GetItemsError>,
+  ): QueryFilters<GetItems200Response, GetItemsError> {
+    return {
+      queryKey: this._getItemsQueryKey(input),
+      ...filter,
+    };
+  }
+  private _getItemsInfiniteQueryOptions(
+    input: GetItemsRequest,
+    options: Omit<
+      UseInfiniteQueryOptions<
+        GetItems200Response,
+        GetItemsError,
+        InfiniteData<GetItems200Response>,
+        GetItems200Response,
+        unknown[],
+        string | undefined | null
+      >,
+      'queryFn' | 'queryKey' | 'initialPageParam'
+    > &
+      Partial<
+        Pick<
+          UseInfiniteQueryOptions<
+            GetItems200Response,
+            GetItemsError,
+            InfiniteData<GetItems200Response>,
+            GetItems200Response,
+            unknown[],
+            string | undefined | null
+          >,
+          'queryFn' | 'queryKey' | 'initialPageParam'
+        >
+      >,
+  ): UseInfiniteQueryOptions<
+    GetItems200Response,
+    GetItemsError,
+    InfiniteData<GetItems200Response>,
+    GetItems200Response,
+    unknown[],
+    string | undefined | null
+  > {
+    return {
+      queryKey: this._getItemsQueryKey(input),
+      queryFn: ({ pageParam }) =>
+        this.$client.getItems({ ...input, cursor: pageParam as any }),
+      initialPageParam: undefined,
+      ...options,
+    };
+  }
+
+  public getItems = {
+    queryKey: this._getItemsQueryKey.bind(this),
+    queryOptions: this._getItemsQueryOptions.bind(this),
+    queryFilter: this._getItemsQueryFilter.bind(this),
+    infiniteQueryOptions: this._getItemsInfiniteQueryOptions.bind(this),
+  };
+}
+"
+`;
+
+exports[`openApiTsHooksGenerator > should handle GET operation with x-mutation: true correctly 1`] = `
+"import type { UseMutationOptions } from '@tanstack/react-query';
+import type {
+  TriggerActionRequest,
+  TriggerActionError,
+  TriggerAction200Response,
+} from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._triggerActionMutationKey = this._triggerActionMutationKey.bind(this);
+    this._triggerActionMutationOptions =
+      this._triggerActionMutationOptions.bind(this);
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _triggerActionMutationKey() {
+    return [...this.queryKey(), 'triggerAction'];
+  }
+  private _triggerActionMutationOptions(
+    options?: UseMutationOptions<
+      TriggerAction200Response,
+      TriggerActionError,
+      TriggerActionRequest
+    >,
+  ): UseMutationOptions<
+    TriggerAction200Response,
+    TriggerActionError,
+    TriggerActionRequest
+  > {
+    return {
+      mutationFn: (input) => this.$client.triggerAction(input),
+      mutationKey: this._triggerActionMutationKey(),
+      ...options,
+    };
+  }
+
+  public triggerAction = {
+    mutationKey: this._triggerActionMutationKey.bind(this),
+    mutationOptions: this._triggerActionMutationOptions.bind(this),
+  };
+}
+"
+`;
+
+exports[`openApiTsHooksGenerator > should handle POST operation with x-query: true correctly 1`] = `
+"import type { QueryFilters, UseQueryOptions } from '@tanstack/react-query';
+import type {
+  SearchDataRequest,
+  SearchDataError,
+  SearchData200Response,
+} from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._searchDataQueryKey = this._searchDataQueryKey.bind(this);
+    this._searchDataQueryOptions = this._searchDataQueryOptions.bind(this);
+    this._searchDataQueryFilter = this._searchDataQueryFilter.bind(this);
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _searchDataQueryKey(input: SearchDataRequest) {
+    return [...this.queryKey(), 'searchData', input];
+  }
+  private _searchDataQueryOptions(
+    input: SearchDataRequest,
+    options?: Omit<
+      UseQueryOptions<SearchData200Response, SearchDataError>,
+      'queryFn' | 'queryKey'
+    > &
+      Partial<
+        Pick<
+          UseQueryOptions<SearchData200Response, SearchDataError>,
+          'queryFn' | 'queryKey'
+        >
+      >,
+  ): UseQueryOptions<SearchData200Response, SearchDataError> {
+    return {
+      queryFn: () => this.$client.searchData(input),
+      queryKey: this._searchDataQueryKey(input),
+      ...options,
+    };
+  }
+  private _searchDataQueryFilter(
+    input: SearchDataRequest,
+    filter?: QueryFilters<SearchData200Response, SearchDataError>,
+  ): QueryFilters<SearchData200Response, SearchDataError> {
+    return {
+      queryKey: this._searchDataQueryKey(input),
+      ...filter,
+    };
+  }
+
+  public searchData = {
+    queryKey: this._searchDataQueryKey.bind(this),
+    queryOptions: this._searchDataQueryOptions.bind(this),
+    queryFilter: this._searchDataQueryFilter.bind(this),
+  };
+}
+"
+`;
+
+exports[`openApiTsHooksGenerator > should handle infinite query errors correctly 1`] = `
+"import type {
+  QueryFilters,
+  UseQueryOptions,
+  UseInfiniteQueryOptions,
+  InfiniteData,
+} from '@tanstack/react-query';
+import type {
+  GetItemsRequest,
+  GetItemsError,
+  GetItems200Response,
+} from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._getItemsQueryKey = this._getItemsQueryKey.bind(this);
+    this._getItemsQueryOptions = this._getItemsQueryOptions.bind(this);
+    this._getItemsQueryFilter = this._getItemsQueryFilter.bind(this);
+    this._getItemsInfiniteQueryOptions =
+      this._getItemsInfiniteQueryOptions.bind(this);
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _getItemsQueryKey(input: GetItemsRequest) {
+    return [...this.queryKey(), 'getItems', input];
+  }
+  private _getItemsQueryOptions(
+    input: GetItemsRequest,
+    options?: Omit<
+      UseQueryOptions<GetItems200Response, GetItemsError>,
+      'queryFn' | 'queryKey'
+    > &
+      Partial<
+        Pick<
+          UseQueryOptions<GetItems200Response, GetItemsError>,
+          'queryFn' | 'queryKey'
+        >
+      >,
+  ): UseQueryOptions<GetItems200Response, GetItemsError> {
+    return {
+      queryFn: () => this.$client.getItems(input),
+      queryKey: this._getItemsQueryKey(input),
+      ...options,
+    };
+  }
+  private _getItemsQueryFilter(
+    input: GetItemsRequest,
+    filter?: QueryFilters<GetItems200Response, GetItemsError>,
+  ): QueryFilters<GetItems200Response, GetItemsError> {
+    return {
+      queryKey: this._getItemsQueryKey(input),
+      ...filter,
+    };
+  }
+  private _getItemsInfiniteQueryOptions(
+    input: GetItemsRequest,
+    options: Omit<
+      UseInfiniteQueryOptions<
+        GetItems200Response,
+        GetItemsError,
+        InfiniteData<GetItems200Response>,
+        GetItems200Response,
+        unknown[],
+        string | undefined | null
+      >,
+      'queryFn' | 'queryKey' | 'initialPageParam'
+    > &
+      Partial<
+        Pick<
+          UseInfiniteQueryOptions<
+            GetItems200Response,
+            GetItemsError,
+            InfiniteData<GetItems200Response>,
+            GetItems200Response,
+            unknown[],
+            string | undefined | null
+          >,
+          'queryFn' | 'queryKey' | 'initialPageParam'
+        >
+      >,
+  ): UseInfiniteQueryOptions<
+    GetItems200Response,
+    GetItemsError,
+    InfiniteData<GetItems200Response>,
+    GetItems200Response,
+    unknown[],
+    string | undefined | null
+  > {
+    return {
+      queryKey: this._getItemsQueryKey(input),
+      queryFn: ({ pageParam }) =>
+        this.$client.getItems({ ...input, cursor: pageParam as any }),
+      initialPageParam: undefined,
+      ...options,
+    };
+  }
+
+  public getItems = {
+    queryKey: this._getItemsQueryKey.bind(this),
+    queryOptions: this._getItemsQueryOptions.bind(this),
+    queryFilter: this._getItemsQueryFilter.bind(this),
+    infiniteQueryOptions: this._getItemsInfiniteQueryOptions.bind(this),
+  };
+}
+"
+`;
+
+exports[`openApiTsHooksGenerator > should handle infinite query with custom cursor parameter 1`] = `
+"import type {
+  QueryFilters,
+  UseQueryOptions,
+  UseInfiniteQueryOptions,
+  InfiniteData,
+} from '@tanstack/react-query';
+import type {
+  ListRecordsRequest,
+  ListRecordsError,
+  ListRecords200Response,
+} from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._listRecordsQueryKey = this._listRecordsQueryKey.bind(this);
+    this._listRecordsQueryOptions = this._listRecordsQueryOptions.bind(this);
+    this._listRecordsQueryFilter = this._listRecordsQueryFilter.bind(this);
+    this._listRecordsInfiniteQueryOptions =
+      this._listRecordsInfiniteQueryOptions.bind(this);
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _listRecordsQueryKey(input: ListRecordsRequest) {
+    return [...this.queryKey(), 'listRecords', input];
+  }
+  private _listRecordsQueryOptions(
+    input: ListRecordsRequest,
+    options?: Omit<
+      UseQueryOptions<ListRecords200Response, ListRecordsError>,
+      'queryFn' | 'queryKey'
+    > &
+      Partial<
+        Pick<
+          UseQueryOptions<ListRecords200Response, ListRecordsError>,
+          'queryFn' | 'queryKey'
+        >
+      >,
+  ): UseQueryOptions<ListRecords200Response, ListRecordsError> {
+    return {
+      queryFn: () => this.$client.listRecords(input),
+      queryKey: this._listRecordsQueryKey(input),
+      ...options,
+    };
+  }
+  private _listRecordsQueryFilter(
+    input: ListRecordsRequest,
+    filter?: QueryFilters<ListRecords200Response, ListRecordsError>,
+  ): QueryFilters<ListRecords200Response, ListRecordsError> {
+    return {
+      queryKey: this._listRecordsQueryKey(input),
+      ...filter,
+    };
+  }
+  private _listRecordsInfiniteQueryOptions(
+    input: ListRecordsRequest,
+    options: Omit<
+      UseInfiniteQueryOptions<
+        ListRecords200Response,
+        ListRecordsError,
+        InfiniteData<ListRecords200Response>,
+        ListRecords200Response,
+        unknown[],
+        string | undefined | null
+      >,
+      'queryFn' | 'queryKey' | 'initialPageParam'
+    > &
+      Partial<
+        Pick<
+          UseInfiniteQueryOptions<
+            ListRecords200Response,
+            ListRecordsError,
+            InfiniteData<ListRecords200Response>,
+            ListRecords200Response,
+            unknown[],
+            string | undefined | null
+          >,
+          'queryFn' | 'queryKey' | 'initialPageParam'
+        >
+      >,
+  ): UseInfiniteQueryOptions<
+    ListRecords200Response,
+    ListRecordsError,
+    InfiniteData<ListRecords200Response>,
+    ListRecords200Response,
+    unknown[],
+    string | undefined | null
+  > {
+    return {
+      queryKey: this._listRecordsQueryKey(input),
+      queryFn: ({ pageParam }) =>
+        this.$client.listRecords({ ...input, nextToken: pageParam as any }),
+      initialPageParam: undefined,
+      ...options,
+    };
+  }
+
+  public listRecords = {
+    queryKey: this._listRecordsQueryKey.bind(this),
+    queryOptions: this._listRecordsQueryOptions.bind(this),
+    queryFilter: this._listRecordsQueryFilter.bind(this),
+    infiniteQueryOptions: this._listRecordsInfiniteQueryOptions.bind(this),
+  };
+}
+"
+`;
+
+exports[`openApiTsHooksGenerator > should handle mutation errors correctly 1`] = `
+"import type { UseMutationOptions } from '@tanstack/react-query';
+import type {
+  CreateUserRequest,
+  CreateUserError,
+  CreateUser201Response,
+} from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._createUserMutationKey = this._createUserMutationKey.bind(this);
+    this._createUserMutationOptions =
+      this._createUserMutationOptions.bind(this);
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _createUserMutationKey() {
+    return [...this.queryKey(), 'createUser'];
+  }
+  private _createUserMutationOptions(
+    options?: UseMutationOptions<
+      CreateUser201Response,
+      CreateUserError,
+      CreateUserRequest
+    >,
+  ): UseMutationOptions<
+    CreateUser201Response,
+    CreateUserError,
+    CreateUserRequest
+  > {
+    return {
+      mutationFn: (input) => this.$client.createUser(input),
+      mutationKey: this._createUserMutationKey(),
+      ...options,
+    };
+  }
+
+  public createUser = {
+    mutationKey: this._createUserMutationKey.bind(this),
+    mutationOptions: this._createUserMutationOptions.bind(this),
+  };
+}
+"
+`;
+
+exports[`openApiTsHooksGenerator > should handle query errors correctly 1`] = `
+"import type { QueryFilters, UseQueryOptions } from '@tanstack/react-query';
+import type { GetErrorError, GetError200Response } from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._getErrorQueryKey = this._getErrorQueryKey.bind(this);
+    this._getErrorQueryOptions = this._getErrorQueryOptions.bind(this);
+    this._getErrorQueryFilter = this._getErrorQueryFilter.bind(this);
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _getErrorQueryKey() {
+    return [...this.queryKey(), 'getError'];
+  }
+  private _getErrorQueryOptions(
+    options?: Omit<
+      UseQueryOptions<GetError200Response, GetErrorError>,
+      'queryFn' | 'queryKey'
+    > &
+      Partial<
+        Pick<
+          UseQueryOptions<GetError200Response, GetErrorError>,
+          'queryFn' | 'queryKey'
+        >
+      >,
+  ): UseQueryOptions<GetError200Response, GetErrorError> {
+    return {
+      queryFn: () => this.$client.getError(),
+      queryKey: this._getErrorQueryKey(),
+      ...options,
+    };
+  }
+  private _getErrorQueryFilter(
+    filter?: QueryFilters<GetError200Response, GetErrorError>,
+  ): QueryFilters<GetError200Response, GetErrorError> {
+    return {
+      queryKey: this._getErrorQueryKey(),
+      ...filter,
+    };
+  }
+
+  public getError = {
+    queryKey: this._getErrorQueryKey.bind(this),
+    queryOptions: this._getErrorQueryOptions.bind(this),
+    queryFilter: this._getErrorQueryFilter.bind(this),
+  };
+}
+"
+`;
+
+exports[`openApiTsHooksGenerator > should handle streaming infinite query operation correctly 1`] = `
+"import type {
+  QueryFilters,
+  UseQueryOptions,
+  UseInfiniteQueryOptions,
+  InfiniteData,
+  QueryFunctionContext,
+} from '@tanstack/react-query';
+import type {
+  StreamLogsRequest,
+  StreamLogsError,
+  StreamLogs200Response,
+} from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._streamLogsQueryKey = this._streamLogsQueryKey.bind(this);
+    this._streamLogsQueryOptions = this._streamLogsQueryOptions.bind(this);
+    this._streamLogsQueryFilter = this._streamLogsQueryFilter.bind(this);
+    this._streamLogsInfiniteQueryOptions =
+      this._streamLogsInfiniteQueryOptions.bind(this);
+  }
+
+  protected async $queryStream<T>(
+    context: QueryFunctionContext<any>,
+    stream: AsyncIterable<T>,
+  ): Promise<T[]> {
+    const query = context.client
+      .getQueryCache()
+      .find({ queryKey: context.queryKey, exact: true });
+
+    if (query && query.state.data !== undefined) {
+      query.setState({
+        status: 'pending',
+        data: undefined,
+        error: null,
+        fetchStatus: 'fetching',
+      });
+    }
+
+    const chunks: T[] = [];
+    for await (const chunk of stream) {
+      if (context.signal.aborted) {
+        break;
+      }
+      chunks.push(chunk);
+      query?.setState({
+        status: 'success',
+        fetchStatus: 'fetching',
+      });
+      context.client.setQueryData<T[]>(context.queryKey, (prev = []) =>
+        prev.concat(chunk),
+      );
+    }
+    query?.setState({
+      fetchStatus: 'idle',
+    });
+    return chunks;
+  }
+
+  protected async $waitForStream<T>(iterable: AsyncIterable<T>) {
+    const chunks: T[] = [];
+    for await (const chunk of iterable) {
+      chunks.push(chunk);
+    }
+    return chunks;
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _streamLogsQueryKey(input: StreamLogsRequest) {
+    return [...this.queryKey(), 'streamLogs', input];
+  }
+  private _streamLogsQueryOptions(
+    input: StreamLogsRequest,
+    options?: Omit<
+      UseQueryOptions<StreamLogs200Response[], StreamLogsError>,
+      'queryFn' | 'queryKey'
+    > &
+      Partial<
+        Pick<
+          UseQueryOptions<StreamLogs200Response[], StreamLogsError>,
+          'queryFn' | 'queryKey'
+        >
+      >,
+  ): UseQueryOptions<StreamLogs200Response[], StreamLogsError> {
+    return {
+      queryFn: (context) =>
+        this.$queryStream(context, this.$client.streamLogs(input)),
+      queryKey: this._streamLogsQueryKey(input),
+      ...options,
+    };
+  }
+  private _streamLogsQueryFilter(
+    input: StreamLogsRequest,
+    filter?: QueryFilters<StreamLogs200Response[], StreamLogsError>,
+  ): QueryFilters<StreamLogs200Response[], StreamLogsError> {
+    return {
+      queryKey: this._streamLogsQueryKey(input),
+      ...filter,
+    };
+  }
+  private _streamLogsInfiniteQueryOptions(
+    input: StreamLogsRequest,
+    options: Omit<
+      UseInfiniteQueryOptions<
+        StreamLogs200Response[],
+        StreamLogsError,
+        InfiniteData<StreamLogs200Response[]>,
+        StreamLogs200Response[],
+        unknown[],
+        string | undefined | null
+      >,
+      'queryFn' | 'queryKey' | 'initialPageParam'
+    > &
+      Partial<
+        Pick<
+          UseInfiniteQueryOptions<
+            StreamLogs200Response[],
+            StreamLogsError,
+            InfiniteData<StreamLogs200Response[]>,
+            StreamLogs200Response[],
+            unknown[],
+            string | undefined | null
+          >,
+          'queryFn' | 'queryKey' | 'initialPageParam'
+        >
+      >,
+  ): UseInfiniteQueryOptions<
+    StreamLogs200Response[],
+    StreamLogsError,
+    InfiniteData<StreamLogs200Response[]>,
+    StreamLogs200Response[],
+    unknown[],
+    string | undefined | null
+  > {
+    return {
+      queryKey: this._streamLogsQueryKey(input),
+      queryFn: ({ pageParam }) =>
+        this.$waitForStream(
+          this.$client.streamLogs({ ...input, cursor: pageParam as any }),
+        ),
+      initialPageParam: undefined,
+      ...options,
+    };
+  }
+
+  public streamLogs = {
+    queryKey: this._streamLogsQueryKey.bind(this),
+    queryOptions: this._streamLogsQueryOptions.bind(this),
+    queryFilter: this._streamLogsQueryFilter.bind(this),
+    infiniteQueryOptions: this._streamLogsInfiniteQueryOptions.bind(this),
+  };
+}
+"
+`;
+
+exports[`openApiTsHooksGenerator > should handle streaming mutation operation correctly 1`] = `
+"import type {
+  UseMutationOptions,
+  QueryFunctionContext,
+} from '@tanstack/react-query';
+import type {
+  UploadStreamRequest,
+  UploadStreamError,
+  UploadStream200Response,
+} from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._uploadStreamMutationKey = this._uploadStreamMutationKey.bind(this);
+    this._uploadStreamMutationOptions =
+      this._uploadStreamMutationOptions.bind(this);
+  }
+
+  protected async $queryStream<T>(
+    context: QueryFunctionContext<any>,
+    stream: AsyncIterable<T>,
+  ): Promise<T[]> {
+    const query = context.client
+      .getQueryCache()
+      .find({ queryKey: context.queryKey, exact: true });
+
+    if (query && query.state.data !== undefined) {
+      query.setState({
+        status: 'pending',
+        data: undefined,
+        error: null,
+        fetchStatus: 'fetching',
+      });
+    }
+
+    const chunks: T[] = [];
+    for await (const chunk of stream) {
+      if (context.signal.aborted) {
+        break;
+      }
+      chunks.push(chunk);
+      query?.setState({
+        status: 'success',
+        fetchStatus: 'fetching',
+      });
+      context.client.setQueryData<T[]>(context.queryKey, (prev = []) =>
+        prev.concat(chunk),
+      );
+    }
+    query?.setState({
+      fetchStatus: 'idle',
+    });
+    return chunks;
+  }
+
+  protected async $waitForStream<T>(iterable: AsyncIterable<T>) {
+    const chunks: T[] = [];
+    for await (const chunk of iterable) {
+      chunks.push(chunk);
+    }
+    return chunks;
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _uploadStreamMutationKey() {
+    return [...this.queryKey(), 'uploadStream'];
+  }
+  private _uploadStreamMutationOptions(
+    options?: UseMutationOptions<
+      AsyncIterableIterator<UploadStream200Response>,
+      UploadStreamError,
+      UploadStreamRequest
+    >,
+  ): UseMutationOptions<
+    AsyncIterableIterator<UploadStream200Response>,
+    UploadStreamError,
+    UploadStreamRequest
+  > {
+    return {
+      mutationFn: async (input) => this.$client.uploadStream(input),
+      mutationKey: this._uploadStreamMutationKey(),
+      ...options,
+    };
+  }
+
+  public uploadStream = {
+    mutationKey: this._uploadStreamMutationKey.bind(this),
+    mutationOptions: this._uploadStreamMutationOptions.bind(this),
+  };
+}
+"
+`;
+
+exports[`openApiTsHooksGenerator > should handle streaming query operation correctly 1`] = `
+"import type {
+  QueryFilters,
+  UseQueryOptions,
+  QueryFunctionContext,
+} from '@tanstack/react-query';
+import type {
+  StreamEventsRequest,
+  StreamEventsError,
+  StreamEvents200Response,
+} from './types.gen.js';
+import { TestApi } from './client.gen.js';
+
+export interface TestApiOptionsProxyConfig {
+  client: TestApi;
+}
+
+export class TestApiOptionsProxy {
+  private $client: TestApi;
+
+  constructor({ client }: TestApiOptionsProxyConfig) {
+    this.$client = client;
+
+    this._streamEventsQueryKey = this._streamEventsQueryKey.bind(this);
+    this._streamEventsQueryOptions = this._streamEventsQueryOptions.bind(this);
+    this._streamEventsQueryFilter = this._streamEventsQueryFilter.bind(this);
+  }
+
+  protected async $queryStream<T>(
+    context: QueryFunctionContext<any>,
+    stream: AsyncIterable<T>,
+  ): Promise<T[]> {
+    const query = context.client
+      .getQueryCache()
+      .find({ queryKey: context.queryKey, exact: true });
+
+    if (query && query.state.data !== undefined) {
+      query.setState({
+        status: 'pending',
+        data: undefined,
+        error: null,
+        fetchStatus: 'fetching',
+      });
+    }
+
+    const chunks: T[] = [];
+    for await (const chunk of stream) {
+      if (context.signal.aborted) {
+        break;
+      }
+      chunks.push(chunk);
+      query?.setState({
+        status: 'success',
+        fetchStatus: 'fetching',
+      });
+      context.client.setQueryData<T[]>(context.queryKey, (prev = []) =>
+        prev.concat(chunk),
+      );
+    }
+    query?.setState({
+      fetchStatus: 'idle',
+    });
+    return chunks;
+  }
+
+  protected async $waitForStream<T>(iterable: AsyncIterable<T>) {
+    const chunks: T[] = [];
+    for await (const chunk of iterable) {
+      chunks.push(chunk);
+    }
+    return chunks;
+  }
+
+  public queryKey = () => ['TestApi'];
+
+  private _streamEventsQueryKey(input: StreamEventsRequest) {
+    return [...this.queryKey(), 'streamEvents', input];
+  }
+  private _streamEventsQueryOptions(
+    input: StreamEventsRequest,
+    options?: Omit<
+      UseQueryOptions<StreamEvents200Response[], StreamEventsError>,
+      'queryFn' | 'queryKey'
+    > &
+      Partial<
+        Pick<
+          UseQueryOptions<StreamEvents200Response[], StreamEventsError>,
+          'queryFn' | 'queryKey'
+        >
+      >,
+  ): UseQueryOptions<StreamEvents200Response[], StreamEventsError> {
+    return {
+      queryFn: (context) =>
+        this.$queryStream(context, this.$client.streamEvents(input)),
+      queryKey: this._streamEventsQueryKey(input),
+      ...options,
+    };
+  }
+  private _streamEventsQueryFilter(
+    input: StreamEventsRequest,
+    filter?: QueryFilters<StreamEvents200Response[], StreamEventsError>,
+  ): QueryFilters<StreamEvents200Response[], StreamEventsError> {
+    return {
+      queryKey: this._streamEventsQueryKey(input),
+      ...filter,
+    };
+  }
+
+  public streamEvents = {
+    queryKey: this._streamEventsQueryKey.bind(this),
+    queryOptions: this._streamEventsQueryOptions.bind(this),
+    queryFilter: this._streamEventsQueryFilter.bind(this),
+  };
+}
+"
+`;