react-query-lightbase-codegen 0.1.0 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/lib/cjs/import-open-api.js +125 -123
  2. package/lib/esm/import-open-api.js +125 -123
  3. package/package.json +1 -1
package/lib/cjs/import-open-api.js CHANGED
@@ -132,7 +132,7 @@ const getObject = (item) => {
132
132
  const doc = (0, exports.isReference)(prop) ? '' : (0, exports.formatDescription)(prop.description, 2);
133
133
  const isRequired = (item.required || []).includes(key);
134
134
  const processedKey = IdentifierRegexp.test(key) ? key : `"${key}"`;
135
- return ` ${doc}${processedKey}${isRequired ? '' : '?'}: ${(0, exports.resolveValue)(prop)};`;
135
+ return `${doc}\n${processedKey}${isRequired ? '' : '?'}: ${(0, exports.resolveValue)(prop)};`;
136
136
  })
137
137
  .join('\n');
138
138
  }
@@ -203,7 +203,10 @@ exports.getParamsInPath = getParamsInPath;
203
203
  */
204
204
  const generateInterface = (name, schema) => {
205
205
  const scalar = (0, exports.getScalar)(schema);
206
- return `${(0, exports.formatDescription)(schema.description)}export interface ${(0, case_1.pascal)(name)} ${scalar}`;
206
+ return `
207
+ ${(0, exports.formatDescription)(schema.description)}
208
+ export interface ${(0, case_1.pascal)(name)} ${scalar}
209
+ `;
207
210
  };
208
211
  exports.generateInterface = generateInterface;
209
212
  /**
@@ -307,7 +310,7 @@ exports.generateResponsesDefinition = generateResponsesDefinition;
307
310
  const formatDescription = (description, tabSize = 0) => description
308
311
  ? `/**\n${description
309
312
  .split('\n')
310
- .map((i) => `${' '.repeat(tabSize)} * ${i}`)
313
+ .map((i) => `${' '.repeat(tabSize)} * ${i}`)
311
314
  .join('\n')}\n${' '.repeat(tabSize)} */${' '.repeat(tabSize)}`
312
315
  : '';
313
316
  exports.formatDescription = formatDescription;
@@ -406,13 +409,13 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
406
409
  // QUERIES
407
410
  if (!requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
408
411
  output += `
409
- type ${componentName}Response = ${genericsTypes}
412
+ type ${componentName}Return = ${genericsTypes}
410
413
  type ${componentName}Variables = {
411
414
  ${paramsTypes}
412
415
  }
413
416
 
414
417
  use${componentName}Query.fetch = async (props: ${componentName}Variables ) => {
415
- const result = await api.${verb}<${componentName}Response>(\`${route.replace(/\{/g, '{props.')}\`);
418
+ const result = await api.${verb}<${componentName}Return>(\`${route.replace(/\{/g, '{props.')}\`);
416
419
  return result.data;
417
420
  }
418
421
  use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
@@ -420,36 +423,36 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
420
423
 
421
424
  use${componentName}Query.updateCache = (
422
425
  params: ${componentName}Variables,
423
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
426
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
424
427
  options?: SetDataOptions | undefined
425
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
428
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
426
429
 
427
430
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
428
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
431
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
429
432
 
430
433
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
431
434
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
432
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
435
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
433
436
 
434
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
435
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
437
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
438
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
436
439
  }
437
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
440
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
438
441
  return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
439
442
  { enabled: ${enabledParam}, ...options }
440
- );}
443
+ );}
441
444
 
442
445
  type ${componentName}MutationProps<T> = {
443
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
446
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
444
447
  }
445
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
448
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
446
449
  return useMutation(async (data) => use${componentName}Query.fetch(data),
447
450
  props?.options
448
451
  )};`;
449
452
  }
450
453
  if (!requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
451
454
  output += `
452
- type ${componentName}Response = ${genericsTypes}
455
+ type ${componentName}Return = ${genericsTypes}
453
456
  type ${componentName}Variables = {
454
457
  ${paramsTypes}
455
458
  ${queryParamsType};
@@ -458,7 +461,7 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
458
461
  use${componentName}Query.fetch = async (props:${componentName}Variables) => {
459
462
  const {${paramsInPath.join(', ')}, ...queryParams} = props
460
463
  const params = queryString.stringify(queryParams);
461
- const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`)
464
+ const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`)
462
465
  return result.data;
463
466
  }
464
467
 
@@ -467,75 +470,76 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
467
470
 
468
471
  use${componentName}Query.updateCache = (
469
472
  params: ${componentName}Variables,
470
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
473
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
471
474
  options?: SetDataOptions | undefined
472
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
475
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
473
476
 
474
477
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
475
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
478
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
476
479
 
477
480
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
478
481
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
479
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
482
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
480
483
 
481
- type ${componentName}QueryProps<T = ${componentName}Response> ${componentName}Variables & {
482
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
484
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
485
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
483
486
  }
484
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
485
- return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), {
486
- enabled: ${enabledParam}, ...options }
487
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
488
+ return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
489
+ { enabled: ${enabledParam}, ...options }
487
490
  );}
488
491
 
489
492
  type ${componentName}MutationProps<T> = {
490
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
493
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
491
494
  }
492
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
495
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
493
496
  return useMutation(async (data) => use${componentName}Query.fetch(data),
494
497
  props?.options
495
498
  )};`;
496
499
  }
497
500
  if (!requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
498
501
  output += `
499
- type ${componentName}Response = ${genericsTypes}
502
+ type ${componentName}Return = ${genericsTypes}
500
503
  use${componentName}Query.fetch = async () => {
501
- const result = await api.${verb}<${componentName}Response>(\`${route}\`);
504
+ const result = await api.${verb}<${componentName}Return>(\`${route}\`);
502
505
  return result.data;
503
506
  }
504
507
  use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
505
508
  use${componentName}Query.queryKey = (): QueryKey => use${componentName}Query.baseKey()
506
509
 
507
510
  use${componentName}Query.updateCache = (
508
- params: undefined,
509
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
511
+ _params: undefined,
512
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
510
513
  options?: SetDataOptions | undefined
511
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(), updater, options);
514
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(), updater, options);
512
515
 
513
516
  use${componentName}Query.prefetch = () =>
514
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(), ()=> use${componentName}Query.fetch());
517
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(), ()=> use${componentName}Query.fetch());
515
518
 
516
519
  use${componentName}Query.cancelQueries = () => queryClient.cancelQueries(use${componentName}Query.queryKey())
517
520
  use${componentName}Query.invalidate = () =>
518
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey());
521
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey());
519
522
 
520
523
 
521
- type ${componentName}QueryProps<T = ${componentName}Response> = {
522
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
524
+ type ${componentName}QueryProps<T = ${componentName}Return> = {
525
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
523
526
  }
524
- export function use${componentName}Query<T = ${componentName}Response>(props?: ${componentName}QueryProps<T>) {
527
+ export function use${componentName}Query<T = ${componentName}Return>(props?: ${componentName}QueryProps<T>) {
525
528
  return useQuery(use${componentName}Query.queryKey(), use${componentName}Query.fetch, props?.options
526
529
  );}
527
530
 
528
531
  type ${componentName}MutationProps<T> = {
529
- options?: UseMutationOptions<${componentName}Response, AxiosError, void, T>
532
+ options?: UseMutationOptions<${componentName}Return, AxiosError, void, T>
530
533
  }
531
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
534
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
532
535
  return useMutation(async () => use${componentName}Query.fetch(),
533
536
  props?.options
534
537
  )};`;
535
538
  }
536
539
  if (!requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
537
540
  output += `
538
- type ${componentName}Response = ${genericsTypes}
541
+
542
+ type ${componentName}Return = ${genericsTypes}
539
543
  type ${componentName}Variables = {
540
544
  ${queryParamsType}
541
545
  }
@@ -544,7 +548,7 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
544
548
  const params = queryString.stringify({${queryParams
545
549
  .map((param) => `"${param.name}": props["${param.name}"]`)
546
550
  .join(',')}});
547
- const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`)
551
+ const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`)
548
552
  return result.data;
549
553
  }
550
554
 
@@ -553,23 +557,23 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
553
557
 
554
558
  use${componentName}Query.updateCache = (
555
559
  params: ${componentName}Variables,
556
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
560
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
557
561
  options?: SetDataOptions | undefined
558
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
562
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
559
563
 
560
564
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
561
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
565
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
562
566
 
563
567
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
564
568
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
565
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
569
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
566
570
 
567
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>}) {
571
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>}) {
568
572
  return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
569
573
  { enabled: ${enabledParam}, ...options }
570
574
  );}
571
575
 
572
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: { options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>}) {
576
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: { options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>}) {
573
577
  return useMutation(async (data) => use${componentName}Query.fetch(data),
574
578
  props?.options
575
579
  )};
@@ -577,11 +581,11 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
577
581
  }
578
582
  if (requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
579
583
  output += `
580
- type ${componentName}Response = ${genericsTypes}
584
+ type ${componentName}Return = ${genericsTypes}
581
585
  type ${componentName}Variables = ${requestBodyComponent};
582
586
 
583
587
  use${componentName}Query.fetch = async (body: ${componentName}Variables) => {
584
- const result = await api.${verb}<${componentName}Response>(\`${route}\`, body)
588
+ const result = await api.${verb}<${componentName}Return>(\`${route}\`, body)
585
589
  return result.data
586
590
  }
587
591
 
@@ -590,48 +594,48 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
590
594
 
591
595
  use${componentName}Query.updateCache = (
592
596
  params: ${componentName}Variables,
593
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
597
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
594
598
  options?: SetDataOptions | undefined
595
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
599
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
596
600
 
597
601
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
598
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
602
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
599
603
 
600
604
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
601
605
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
602
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
606
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
603
607
 
604
608
 
605
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
606
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
609
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
610
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
607
611
  }
608
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
612
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
609
613
  return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body), options
610
614
  );}
611
615
 
612
616
  type ${componentName}MutationProps<T> = {
613
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
617
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
614
618
  }
615
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
619
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
616
620
  return useMutation(async (body) => use${componentName}Query.fetch(body),
617
621
  props?.options
618
622
  )};`;
619
623
  }
620
624
  if (requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
621
625
  output += `
622
- type ${componentName}Response = ${genericsTypes}
626
+ type ${componentName}Return = ${genericsTypes}
623
627
  type ${componentName}Variables = {
624
628
  body: ${requestBodyComponent}
625
629
  ${paramsTypes}
626
630
  }
627
631
 
628
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
629
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
632
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
633
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
630
634
  }
631
635
 
632
636
  use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
633
637
  const {${paramsInPath.join(', ')}, ...body} = props
634
- const result = await api.${verb}<${componentName}Response>(\`${route}\`, body)
638
+ const result = await api.${verb}<${componentName}Return>(\`${route}\`, body)
635
639
  return result.data
636
640
  }
637
641
  use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
@@ -639,48 +643,48 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
639
643
 
640
644
  use${componentName}Query.updateCache = (
641
645
  params: ${componentName}Variables,
642
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
646
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
643
647
  options?: SetDataOptions | undefined
644
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
648
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
645
649
 
646
650
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
647
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
651
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
648
652
 
649
653
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
650
654
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
651
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
655
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
652
656
 
653
657
 
654
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
655
- return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), {
656
- enabled: ${enabledParam}, ...options }
658
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
659
+ return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
660
+ { enabled: ${enabledParam}, ...options }
657
661
  );}
658
662
 
659
663
  type ${componentName}MutationProps<T> = {
660
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
664
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
661
665
  }
662
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
666
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
663
667
  return useMutation(async (body) => use${componentName}Query.fetch(body),
664
668
  props?.options
665
669
  )};`;
666
670
  }
667
671
  if (requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
668
672
  output += `
669
- type ${componentName}Response = ${genericsTypes}
673
+ type ${componentName}Return = ${genericsTypes}
670
674
  type ${componentName}Variables = {
671
675
  body: ${requestBodyComponent}
672
676
  ${queryParamsType}
673
677
  }
674
678
 
675
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
676
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
679
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
680
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
677
681
  }
678
682
 
679
683
  use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
680
684
  const params = queryString.stringify({
681
685
  ${queryParams.map((param) => `["${param.name}"]: props["${param.name}"]`).join(',')}
682
686
  });
683
- const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`, props.body)
687
+ const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`, props.body)
684
688
  return result.data
685
689
  }
686
690
  use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
@@ -688,28 +692,28 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
688
692
 
689
693
  use${componentName}Query.updateCache = (
690
694
  params: ${componentName}Variables,
691
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
695
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
692
696
  options?: SetDataOptions | undefined
693
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
697
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
694
698
 
695
699
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
696
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
700
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
697
701
 
698
702
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
699
703
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
700
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
704
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
701
705
 
702
706
 
703
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
704
- return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), {
705
- enabled: ${enabledParam}, ...options }
707
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
708
+ return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
709
+ { enabled: ${enabledParam}, ...options }
706
710
  );}
707
711
 
708
712
 
709
713
  type ${componentName}MutationProps<T> = {
710
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
714
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
711
715
  }
712
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
716
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
713
717
  return useMutation(async (body) => use${componentName}Query.fetch(body),
714
718
  props?.options
715
719
  )};`;
@@ -731,13 +735,13 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
731
735
  }
732
736
  if (!requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
733
737
  output += `
734
- type ${componentName}Response = ${genericsTypes}
738
+ type ${componentName}Return = ${genericsTypes}
735
739
  type ${componentName}Variables = {
736
740
  ${headerParam}
737
741
  };
738
742
 
739
743
  use${componentName}Query.fetch = async (headers: ${componentName}Variables) => {
740
- const result = await api.${verb}<${componentName}Response>(\`${route}\`, {headers: headers});
744
+ const result = await api.${verb}<${componentName}Return>(\`${route}\`, {headers: headers});
741
745
  return result.data;
742
746
  }
743
747
 
@@ -746,39 +750,37 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
746
750
 
747
751
  use${componentName}Query.updateCache = (
748
752
  params: ${componentName}Variables,
749
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
753
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
750
754
  options?: SetDataOptions | undefined
751
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
755
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
752
756
 
753
757
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
754
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
758
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
755
759
 
756
760
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
757
761
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
758
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
762
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
759
763
 
760
764
 
761
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
762
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
765
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
766
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
763
767
  }
764
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
768
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
765
769
  return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
766
770
  { enabled: ${enabledParam}, ...options }
767
771
  );}
768
772
 
769
-
770
-
771
773
  type ${componentName}MutationProps<T> = {
772
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
774
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
773
775
  }
774
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
776
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
775
777
  return useMutation(async (data) => use${componentName}Query.fetch(data),
776
778
  props?.options
777
779
  )};`;
778
780
  }
779
781
  if (!requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
780
782
  output += `
781
- type ${componentName}Response = ${genericsTypes}
783
+ type ${componentName}Return = ${genericsTypes}
782
784
 
783
785
  type ${componentName}Variables = {
784
786
  ${headerParam}
@@ -792,7 +794,7 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
792
794
  const headers = {
793
795
  ${headerParams.map((p) => `"${p.name}": data["${p.name}"]`).join(',')}
794
796
  }
795
- const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`, {headers})
797
+ const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`, {headers})
796
798
  return result.data;
797
799
  }
798
800
  use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
@@ -800,37 +802,37 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
800
802
 
801
803
  use${componentName}Query.updateCache = (
802
804
  params: ${componentName}Variables,
803
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
805
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
804
806
  options?: SetDataOptions | undefined
805
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
807
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
806
808
 
807
809
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
808
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
810
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
809
811
 
810
812
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
811
813
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
812
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
814
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
813
815
 
814
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
815
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
816
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
817
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
816
818
  }
817
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
819
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
818
820
  return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
819
821
  { enabled: ${enabledParam}, ...options }
820
822
  );}
821
823
 
822
824
  type ${componentName}MutationProps<T> = {
823
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
825
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
824
826
  }
825
827
 
826
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
828
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
827
829
  return useMutation(async (data) => use${componentName}Query.fetch(data),
828
830
  props?.options
829
831
  )};`;
830
832
  }
831
833
  if (requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
832
834
  output += `
833
- type ${componentName}Response = ${genericsTypes}
835
+ type ${componentName}Return = ${genericsTypes}
834
836
 
835
837
  type ${componentName}Variables = {
836
838
  body: ${requestBodyComponent}
@@ -841,7 +843,7 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
841
843
  const headers = {
842
844
  ${headerParams.map((param) => `"${param.name}": body["${param.name}"]`).join(',')}
843
845
  }
844
- const result = await api.${verb}<${componentName}Response>(\`${route}\`, body, {headers})
846
+ const result = await api.${verb}<${componentName}Return>(\`${route}\`, body, {headers})
845
847
  return result.data
846
848
  }
847
849
 
@@ -850,30 +852,30 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
850
852
 
851
853
  use${componentName}Query.updateCache = (
852
854
  params: ${componentName}Variables,
853
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
855
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
854
856
  options?: SetDataOptions | undefined
855
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
857
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
856
858
 
857
859
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
858
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
860
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
859
861
 
860
862
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
861
863
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
862
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
864
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
863
865
 
864
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
865
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
866
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
867
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
866
868
  }
867
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
868
- return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body),{
869
- enabled: ${enabledParam}, ...options }
870
- );}
869
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
870
+ return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body),
871
+ { enabled: ${enabledParam}, ...options }
872
+ );}
871
873
 
872
874
 
873
875
  type ${componentName}MutationProps<T> = {
874
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
876
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
875
877
  }
876
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
878
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
877
879
  return useMutation(async (body) => use${componentName}Query.fetch(body),
878
880
  props?.options
879
881
  )};`;
package/lib/esm/import-open-api.js CHANGED
@@ -122,7 +122,7 @@ export const getObject = (item) => {
122
122
  const doc = isReference(prop) ? '' : formatDescription(prop.description, 2);
123
123
  const isRequired = (item.required || []).includes(key);
124
124
  const processedKey = IdentifierRegexp.test(key) ? key : `"${key}"`;
125
- return ` ${doc}${processedKey}${isRequired ? '' : '?'}: ${resolveValue(prop)};`;
125
+ return `${doc}\n${processedKey}${isRequired ? '' : '?'}: ${resolveValue(prop)};`;
126
126
  })
127
127
  .join('\n');
128
128
  }
@@ -189,7 +189,10 @@ export const getParamsInPath = (path) => {
189
189
  */
190
190
  export const generateInterface = (name, schema) => {
191
191
  const scalar = getScalar(schema);
192
- return `${formatDescription(schema.description)}export interface ${pascal(name)} ${scalar}`;
192
+ return `
193
+ ${formatDescription(schema.description)}
194
+ export interface ${pascal(name)} ${scalar}
195
+ `;
193
196
  };
194
197
  /**
195
198
  * Propagate every `discriminator.propertyName` mapping to the original ref
@@ -288,7 +291,7 @@ export const generateResponsesDefinition = (responses = {}) => {
288
291
  export const formatDescription = (description, tabSize = 0) => description
289
292
  ? `/**\n${description
290
293
  .split('\n')
291
- .map((i) => `${' '.repeat(tabSize)} * ${i}`)
294
+ .map((i) => `${' '.repeat(tabSize)} * ${i}`)
292
295
  .join('\n')}\n${' '.repeat(tabSize)} */${' '.repeat(tabSize)}`
293
296
  : '';
294
297
  /**
@@ -386,13 +389,13 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
386
389
  // QUERIES
387
390
  if (!requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
388
391
  output += `
389
- type ${componentName}Response = ${genericsTypes}
392
+ type ${componentName}Return = ${genericsTypes}
390
393
  type ${componentName}Variables = {
391
394
  ${paramsTypes}
392
395
  }
393
396
 
394
397
  use${componentName}Query.fetch = async (props: ${componentName}Variables ) => {
395
- const result = await api.${verb}<${componentName}Response>(\`${route.replace(/\{/g, '{props.')}\`);
398
+ const result = await api.${verb}<${componentName}Return>(\`${route.replace(/\{/g, '{props.')}\`);
396
399
  return result.data;
397
400
  }
398
401
  use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
@@ -400,36 +403,36 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
400
403
 
401
404
  use${componentName}Query.updateCache = (
402
405
  params: ${componentName}Variables,
403
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
406
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
404
407
  options?: SetDataOptions | undefined
405
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
408
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
406
409
 
407
410
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
408
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
411
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
409
412
 
410
413
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
411
414
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
412
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
415
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
413
416
 
414
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
415
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
417
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
418
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
416
419
  }
417
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
420
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
418
421
  return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
419
422
  { enabled: ${enabledParam}, ...options }
420
- );}
423
+ );}
421
424
 
422
425
  type ${componentName}MutationProps<T> = {
423
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
426
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
424
427
  }
425
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
428
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
426
429
  return useMutation(async (data) => use${componentName}Query.fetch(data),
427
430
  props?.options
428
431
  )};`;
429
432
  }
430
433
  if (!requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
431
434
  output += `
432
- type ${componentName}Response = ${genericsTypes}
435
+ type ${componentName}Return = ${genericsTypes}
433
436
  type ${componentName}Variables = {
434
437
  ${paramsTypes}
435
438
  ${queryParamsType};
@@ -438,7 +441,7 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
438
441
  use${componentName}Query.fetch = async (props:${componentName}Variables) => {
439
442
  const {${paramsInPath.join(', ')}, ...queryParams} = props
440
443
  const params = queryString.stringify(queryParams);
441
- const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`)
444
+ const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`)
442
445
  return result.data;
443
446
  }
444
447
 
@@ -447,75 +450,76 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
447
450
 
448
451
  use${componentName}Query.updateCache = (
449
452
  params: ${componentName}Variables,
450
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
453
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
451
454
  options?: SetDataOptions | undefined
452
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
455
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
453
456
 
454
457
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
455
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
458
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
456
459
 
457
460
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
458
461
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
459
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
462
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
460
463
 
461
- type ${componentName}QueryProps<T = ${componentName}Response> ${componentName}Variables & {
462
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
464
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
465
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
463
466
  }
464
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
465
- return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), {
466
- enabled: ${enabledParam}, ...options }
467
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
468
+ return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
469
+ { enabled: ${enabledParam}, ...options }
467
470
  );}
468
471
 
469
472
  type ${componentName}MutationProps<T> = {
470
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
473
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
471
474
  }
472
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
475
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
473
476
  return useMutation(async (data) => use${componentName}Query.fetch(data),
474
477
  props?.options
475
478
  )};`;
476
479
  }
477
480
  if (!requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
478
481
  output += `
479
- type ${componentName}Response = ${genericsTypes}
482
+ type ${componentName}Return = ${genericsTypes}
480
483
  use${componentName}Query.fetch = async () => {
481
- const result = await api.${verb}<${componentName}Response>(\`${route}\`);
484
+ const result = await api.${verb}<${componentName}Return>(\`${route}\`);
482
485
  return result.data;
483
486
  }
484
487
  use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
485
488
  use${componentName}Query.queryKey = (): QueryKey => use${componentName}Query.baseKey()
486
489
 
487
490
  use${componentName}Query.updateCache = (
488
- params: undefined,
489
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
491
+ _params: undefined,
492
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
490
493
  options?: SetDataOptions | undefined
491
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(), updater, options);
494
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(), updater, options);
492
495
 
493
496
  use${componentName}Query.prefetch = () =>
494
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(), ()=> use${componentName}Query.fetch());
497
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(), ()=> use${componentName}Query.fetch());
495
498
 
496
499
  use${componentName}Query.cancelQueries = () => queryClient.cancelQueries(use${componentName}Query.queryKey())
497
500
  use${componentName}Query.invalidate = () =>
498
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey());
501
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey());
499
502
 
500
503
 
501
- type ${componentName}QueryProps<T = ${componentName}Response> = {
502
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
504
+ type ${componentName}QueryProps<T = ${componentName}Return> = {
505
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
503
506
  }
504
- export function use${componentName}Query<T = ${componentName}Response>(props?: ${componentName}QueryProps<T>) {
507
+ export function use${componentName}Query<T = ${componentName}Return>(props?: ${componentName}QueryProps<T>) {
505
508
  return useQuery(use${componentName}Query.queryKey(), use${componentName}Query.fetch, props?.options
506
509
  );}
507
510
 
508
511
  type ${componentName}MutationProps<T> = {
509
- options?: UseMutationOptions<${componentName}Response, AxiosError, void, T>
512
+ options?: UseMutationOptions<${componentName}Return, AxiosError, void, T>
510
513
  }
511
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
514
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
512
515
  return useMutation(async () => use${componentName}Query.fetch(),
513
516
  props?.options
514
517
  )};`;
515
518
  }
516
519
  if (!requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
517
520
  output += `
518
- type ${componentName}Response = ${genericsTypes}
521
+
522
+ type ${componentName}Return = ${genericsTypes}
519
523
  type ${componentName}Variables = {
520
524
  ${queryParamsType}
521
525
  }
@@ -524,7 +528,7 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
524
528
  const params = queryString.stringify({${queryParams
525
529
  .map((param) => `"${param.name}": props["${param.name}"]`)
526
530
  .join(',')}});
527
- const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`)
531
+ const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`)
528
532
  return result.data;
529
533
  }
530
534
 
@@ -533,23 +537,23 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
533
537
 
534
538
  use${componentName}Query.updateCache = (
535
539
  params: ${componentName}Variables,
536
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
540
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
537
541
  options?: SetDataOptions | undefined
538
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
542
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
539
543
 
540
544
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
541
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
545
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
542
546
 
543
547
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
544
548
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
545
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
549
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
546
550
 
547
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>}) {
551
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>}) {
548
552
  return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
549
553
  { enabled: ${enabledParam}, ...options }
550
554
  );}
551
555
 
552
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: { options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>}) {
556
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: { options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>}) {
553
557
  return useMutation(async (data) => use${componentName}Query.fetch(data),
554
558
  props?.options
555
559
  )};
@@ -557,11 +561,11 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
557
561
  }
558
562
  if (requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
559
563
  output += `
560
- type ${componentName}Response = ${genericsTypes}
564
+ type ${componentName}Return = ${genericsTypes}
561
565
  type ${componentName}Variables = ${requestBodyComponent};
562
566
 
563
567
  use${componentName}Query.fetch = async (body: ${componentName}Variables) => {
564
- const result = await api.${verb}<${componentName}Response>(\`${route}\`, body)
568
+ const result = await api.${verb}<${componentName}Return>(\`${route}\`, body)
565
569
  return result.data
566
570
  }
567
571
 
@@ -570,48 +574,48 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
570
574
 
571
575
  use${componentName}Query.updateCache = (
572
576
  params: ${componentName}Variables,
573
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
577
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
574
578
  options?: SetDataOptions | undefined
575
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
579
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
576
580
 
577
581
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
578
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
582
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
579
583
 
580
584
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
581
585
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
582
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
586
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
583
587
 
584
588
 
585
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
586
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
589
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
590
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
587
591
  }
588
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
592
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
589
593
  return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body), options
590
594
  );}
591
595
 
592
596
  type ${componentName}MutationProps<T> = {
593
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
597
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
594
598
  }
595
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
599
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
596
600
  return useMutation(async (body) => use${componentName}Query.fetch(body),
597
601
  props?.options
598
602
  )};`;
599
603
  }
600
604
  if (requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
601
605
  output += `
602
- type ${componentName}Response = ${genericsTypes}
606
+ type ${componentName}Return = ${genericsTypes}
603
607
  type ${componentName}Variables = {
604
608
  body: ${requestBodyComponent}
605
609
  ${paramsTypes}
606
610
  }
607
611
 
608
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
609
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
612
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
613
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
610
614
  }
611
615
 
612
616
  use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
613
617
  const {${paramsInPath.join(', ')}, ...body} = props
614
- const result = await api.${verb}<${componentName}Response>(\`${route}\`, body)
618
+ const result = await api.${verb}<${componentName}Return>(\`${route}\`, body)
615
619
  return result.data
616
620
  }
617
621
  use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
@@ -619,48 +623,48 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
619
623
 
620
624
  use${componentName}Query.updateCache = (
621
625
  params: ${componentName}Variables,
622
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
626
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
623
627
  options?: SetDataOptions | undefined
624
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
628
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
625
629
 
626
630
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
627
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
631
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
628
632
 
629
633
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
630
634
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
631
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
635
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
632
636
 
633
637
 
634
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
635
- return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), {
636
- enabled: ${enabledParam}, ...options }
638
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
639
+ return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
640
+ { enabled: ${enabledParam}, ...options }
637
641
  );}
638
642
 
639
643
  type ${componentName}MutationProps<T> = {
640
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
644
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
641
645
  }
642
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
646
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
643
647
  return useMutation(async (body) => use${componentName}Query.fetch(body),
644
648
  props?.options
645
649
  )};`;
646
650
  }
647
651
  if (requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
648
652
  output += `
649
- type ${componentName}Response = ${genericsTypes}
653
+ type ${componentName}Return = ${genericsTypes}
650
654
  type ${componentName}Variables = {
651
655
  body: ${requestBodyComponent}
652
656
  ${queryParamsType}
653
657
  }
654
658
 
655
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
656
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
659
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
660
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
657
661
  }
658
662
 
659
663
  use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
660
664
  const params = queryString.stringify({
661
665
  ${queryParams.map((param) => `["${param.name}"]: props["${param.name}"]`).join(',')}
662
666
  });
663
- const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`, props.body)
667
+ const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`, props.body)
664
668
  return result.data
665
669
  }
666
670
  use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
@@ -668,28 +672,28 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
668
672
 
669
673
  use${componentName}Query.updateCache = (
670
674
  params: ${componentName}Variables,
671
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
675
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
672
676
  options?: SetDataOptions | undefined
673
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
677
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
674
678
 
675
679
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
676
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
680
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
677
681
 
678
682
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
679
683
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
680
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
684
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
681
685
 
682
686
 
683
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
684
- return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), {
685
- enabled: ${enabledParam}, ...options }
687
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
688
+ return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
689
+ { enabled: ${enabledParam}, ...options }
686
690
  );}
687
691
 
688
692
 
689
693
  type ${componentName}MutationProps<T> = {
690
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
694
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
691
695
  }
692
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
696
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
693
697
  return useMutation(async (body) => use${componentName}Query.fetch(body),
694
698
  props?.options
695
699
  )};`;
@@ -711,13 +715,13 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
711
715
  }
712
716
  if (!requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
713
717
  output += `
714
- type ${componentName}Response = ${genericsTypes}
718
+ type ${componentName}Return = ${genericsTypes}
715
719
  type ${componentName}Variables = {
716
720
  ${headerParam}
717
721
  };
718
722
 
719
723
  use${componentName}Query.fetch = async (headers: ${componentName}Variables) => {
720
- const result = await api.${verb}<${componentName}Response>(\`${route}\`, {headers: headers});
724
+ const result = await api.${verb}<${componentName}Return>(\`${route}\`, {headers: headers});
721
725
  return result.data;
722
726
  }
723
727
 
@@ -726,39 +730,37 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
726
730
 
727
731
  use${componentName}Query.updateCache = (
728
732
  params: ${componentName}Variables,
729
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
733
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
730
734
  options?: SetDataOptions | undefined
731
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
735
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
732
736
 
733
737
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
734
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
738
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
735
739
 
736
740
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
737
741
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
738
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
742
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
739
743
 
740
744
 
741
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
742
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
745
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
746
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
743
747
  }
744
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
748
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
745
749
  return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
746
750
  { enabled: ${enabledParam}, ...options }
747
751
  );}
748
752
 
749
-
750
-
751
753
  type ${componentName}MutationProps<T> = {
752
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
754
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
753
755
  }
754
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
756
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
755
757
  return useMutation(async (data) => use${componentName}Query.fetch(data),
756
758
  props?.options
757
759
  )};`;
758
760
  }
759
761
  if (!requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
760
762
  output += `
761
- type ${componentName}Response = ${genericsTypes}
763
+ type ${componentName}Return = ${genericsTypes}
762
764
 
763
765
  type ${componentName}Variables = {
764
766
  ${headerParam}
@@ -772,7 +774,7 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
772
774
  const headers = {
773
775
  ${headerParams.map((p) => `"${p.name}": data["${p.name}"]`).join(',')}
774
776
  }
775
- const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`, {headers})
777
+ const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`, {headers})
776
778
  return result.data;
777
779
  }
778
780
  use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
@@ -780,37 +782,37 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
780
782
 
781
783
  use${componentName}Query.updateCache = (
782
784
  params: ${componentName}Variables,
783
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
785
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
784
786
  options?: SetDataOptions | undefined
785
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
787
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
786
788
 
787
789
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
788
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
790
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
789
791
 
790
792
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
791
793
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
792
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
794
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
793
795
 
794
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
795
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
796
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
797
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
796
798
  }
797
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
799
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
798
800
  return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
799
801
  { enabled: ${enabledParam}, ...options }
800
802
  );}
801
803
 
802
804
  type ${componentName}MutationProps<T> = {
803
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
805
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
804
806
  }
805
807
 
806
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
808
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
807
809
  return useMutation(async (data) => use${componentName}Query.fetch(data),
808
810
  props?.options
809
811
  )};`;
810
812
  }
811
813
  if (requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
812
814
  output += `
813
- type ${componentName}Response = ${genericsTypes}
815
+ type ${componentName}Return = ${genericsTypes}
814
816
 
815
817
  type ${componentName}Variables = {
816
818
  body: ${requestBodyComponent}
@@ -821,7 +823,7 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
821
823
  const headers = {
822
824
  ${headerParams.map((param) => `"${param.name}": body["${param.name}"]`).join(',')}
823
825
  }
824
- const result = await api.${verb}<${componentName}Response>(\`${route}\`, body, {headers})
826
+ const result = await api.${verb}<${componentName}Return>(\`${route}\`, body, {headers})
825
827
  return result.data
826
828
  }
827
829
 
@@ -830,30 +832,30 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
830
832
 
831
833
  use${componentName}Query.updateCache = (
832
834
  params: ${componentName}Variables,
833
- updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
835
+ updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
834
836
  options?: SetDataOptions | undefined
835
- ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
837
+ ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
836
838
 
837
839
  use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
838
- queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
840
+ queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
839
841
 
840
842
  use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
841
843
  use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
842
- queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
844
+ queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
843
845
 
844
- type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
845
- options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
846
+ type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
847
+ options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
846
848
  }
847
- export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
848
- return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body),{
849
- enabled: ${enabledParam}, ...options }
850
- );}
849
+ export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
850
+ return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body),
851
+ { enabled: ${enabledParam}, ...options }
852
+ );}
851
853
 
852
854
 
853
855
  type ${componentName}MutationProps<T> = {
854
- options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
856
+ options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
855
857
  }
856
- export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
858
+ export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
857
859
  return useMutation(async (body) => use${componentName}Query.fetch(body),
858
860
  props?.options
859
861
  )};`;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "react-query-lightbase-codegen",
3
- "version": "0.1.0",
3
+ "version": "0.1.3",
4
4
  "license": "MIT",
5
5
  "main": "./lib/cjs/index.js",
6
6
  "module": "./lib/esm/index.js",