react-query-lightbase-codegen 0.1.0 → 0.1.1
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.
- package/lib/cjs/import-open-api.js +141 -123
- package/lib/esm/import-open-api.js +141 -123
- package/package.json +1 -1
|
@@ -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
|
|
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
|
|
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)} *
|
|
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,14 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
406
409
|
// QUERIES
|
|
407
410
|
if (!requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
|
|
408
411
|
output += `
|
|
409
|
-
|
|
412
|
+
// type1
|
|
413
|
+
type ${componentName}Return = ${genericsTypes}
|
|
410
414
|
type ${componentName}Variables = {
|
|
411
415
|
${paramsTypes}
|
|
412
416
|
}
|
|
413
417
|
|
|
414
418
|
use${componentName}Query.fetch = async (props: ${componentName}Variables ) => {
|
|
415
|
-
const result = await api.${verb}<${componentName}
|
|
419
|
+
const result = await api.${verb}<${componentName}Return>(\`${route.replace(/\{/g, '{props.')}\`);
|
|
416
420
|
return result.data;
|
|
417
421
|
}
|
|
418
422
|
use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
|
|
@@ -420,36 +424,39 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
420
424
|
|
|
421
425
|
use${componentName}Query.updateCache = (
|
|
422
426
|
params: ${componentName}Variables,
|
|
423
|
-
updater: Updater<${componentName}
|
|
427
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
424
428
|
options?: SetDataOptions | undefined
|
|
425
|
-
) => queryClient.setQueryData<${componentName}
|
|
429
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
426
430
|
|
|
427
431
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
428
|
-
queryClient.prefetchQuery<${componentName}
|
|
432
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
429
433
|
|
|
430
434
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
431
435
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
432
|
-
queryClient.invalidateQueries<${componentName}
|
|
436
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
433
437
|
|
|
434
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
435
|
-
options?: UseQueryOptions<${componentName}
|
|
438
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
439
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
436
440
|
}
|
|
437
|
-
export function use${componentName}Query<T = ${componentName}
|
|
441
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
438
442
|
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
439
443
|
{ enabled: ${enabledParam}, ...options }
|
|
440
|
-
|
|
444
|
+
);}
|
|
441
445
|
|
|
442
446
|
type ${componentName}MutationProps<T> = {
|
|
443
|
-
options?: UseMutationOptions<${componentName}
|
|
447
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
444
448
|
}
|
|
445
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
449
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
446
450
|
return useMutation(async (data) => use${componentName}Query.fetch(data),
|
|
447
451
|
props?.options
|
|
448
452
|
)};`;
|
|
449
453
|
}
|
|
450
454
|
if (!requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
|
|
451
455
|
output += `
|
|
452
|
-
|
|
456
|
+
import queryString from 'query-string';
|
|
457
|
+
|
|
458
|
+
// type2
|
|
459
|
+
type ${componentName}Return = ${genericsTypes}
|
|
453
460
|
type ${componentName}Variables = {
|
|
454
461
|
${paramsTypes}
|
|
455
462
|
${queryParamsType};
|
|
@@ -458,7 +465,7 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
458
465
|
use${componentName}Query.fetch = async (props:${componentName}Variables) => {
|
|
459
466
|
const {${paramsInPath.join(', ')}, ...queryParams} = props
|
|
460
467
|
const params = queryString.stringify(queryParams);
|
|
461
|
-
const result = await api.${verb}<${componentName}
|
|
468
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`)
|
|
462
469
|
return result.data;
|
|
463
470
|
}
|
|
464
471
|
|
|
@@ -467,38 +474,39 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
467
474
|
|
|
468
475
|
use${componentName}Query.updateCache = (
|
|
469
476
|
params: ${componentName}Variables,
|
|
470
|
-
updater: Updater<${componentName}
|
|
477
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
471
478
|
options?: SetDataOptions | undefined
|
|
472
|
-
) => queryClient.setQueryData<${componentName}
|
|
479
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
473
480
|
|
|
474
481
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
475
|
-
queryClient.prefetchQuery<${componentName}
|
|
482
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
476
483
|
|
|
477
484
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
478
485
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
479
|
-
queryClient.invalidateQueries<${componentName}
|
|
486
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
480
487
|
|
|
481
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
482
|
-
options?: UseQueryOptions<${componentName}
|
|
488
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
489
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
483
490
|
}
|
|
484
|
-
export function use${componentName}Query<T = ${componentName}
|
|
485
|
-
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
486
|
-
|
|
491
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
492
|
+
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
493
|
+
{ enabled: ${enabledParam}, ...options }
|
|
487
494
|
);}
|
|
488
495
|
|
|
489
496
|
type ${componentName}MutationProps<T> = {
|
|
490
|
-
options?: UseMutationOptions<${componentName}
|
|
497
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
491
498
|
}
|
|
492
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
499
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
493
500
|
return useMutation(async (data) => use${componentName}Query.fetch(data),
|
|
494
501
|
props?.options
|
|
495
502
|
)};`;
|
|
496
503
|
}
|
|
497
504
|
if (!requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
|
|
498
505
|
output += `
|
|
499
|
-
|
|
506
|
+
// type3
|
|
507
|
+
type ${componentName}Return = ${genericsTypes}
|
|
500
508
|
use${componentName}Query.fetch = async () => {
|
|
501
|
-
const result = await api.${verb}<${componentName}
|
|
509
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}\`);
|
|
502
510
|
return result.data;
|
|
503
511
|
}
|
|
504
512
|
use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
|
|
@@ -506,36 +514,40 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
506
514
|
|
|
507
515
|
use${componentName}Query.updateCache = (
|
|
508
516
|
params: undefined,
|
|
509
|
-
updater: Updater<${componentName}
|
|
517
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
510
518
|
options?: SetDataOptions | undefined
|
|
511
|
-
) => queryClient.setQueryData<${componentName}
|
|
519
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(), updater, options);
|
|
512
520
|
|
|
513
521
|
use${componentName}Query.prefetch = () =>
|
|
514
|
-
queryClient.prefetchQuery<${componentName}
|
|
522
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(), ()=> use${componentName}Query.fetch());
|
|
515
523
|
|
|
516
524
|
use${componentName}Query.cancelQueries = () => queryClient.cancelQueries(use${componentName}Query.queryKey())
|
|
517
525
|
use${componentName}Query.invalidate = () =>
|
|
518
|
-
queryClient.invalidateQueries<${componentName}
|
|
526
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey());
|
|
519
527
|
|
|
520
528
|
|
|
521
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
522
|
-
options?: UseQueryOptions<${componentName}
|
|
529
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = {
|
|
530
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
523
531
|
}
|
|
524
|
-
export function use${componentName}Query<T = ${componentName}
|
|
532
|
+
export function use${componentName}Query<T = ${componentName}Return>(props?: ${componentName}QueryProps<T>) {
|
|
525
533
|
return useQuery(use${componentName}Query.queryKey(), use${componentName}Query.fetch, props?.options
|
|
526
534
|
);}
|
|
527
535
|
|
|
528
536
|
type ${componentName}MutationProps<T> = {
|
|
529
|
-
options?: UseMutationOptions<${componentName}
|
|
537
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, void, T>
|
|
530
538
|
}
|
|
531
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
539
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
532
540
|
return useMutation(async () => use${componentName}Query.fetch(),
|
|
533
541
|
props?.options
|
|
534
542
|
)};`;
|
|
535
543
|
}
|
|
536
544
|
if (!requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
|
|
537
545
|
output += `
|
|
538
|
-
|
|
546
|
+
// type4
|
|
547
|
+
import queryString from 'query-string';
|
|
548
|
+
|
|
549
|
+
|
|
550
|
+
type ${componentName}Return = ${genericsTypes}
|
|
539
551
|
type ${componentName}Variables = {
|
|
540
552
|
${queryParamsType}
|
|
541
553
|
}
|
|
@@ -544,7 +556,7 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
544
556
|
const params = queryString.stringify({${queryParams
|
|
545
557
|
.map((param) => `"${param.name}": props["${param.name}"]`)
|
|
546
558
|
.join(',')}});
|
|
547
|
-
const result = await api.${verb}<${componentName}
|
|
559
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`)
|
|
548
560
|
return result.data;
|
|
549
561
|
}
|
|
550
562
|
|
|
@@ -553,23 +565,23 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
553
565
|
|
|
554
566
|
use${componentName}Query.updateCache = (
|
|
555
567
|
params: ${componentName}Variables,
|
|
556
|
-
updater: Updater<${componentName}
|
|
568
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
557
569
|
options?: SetDataOptions | undefined
|
|
558
|
-
) => queryClient.setQueryData<${componentName}
|
|
570
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
559
571
|
|
|
560
572
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
561
|
-
queryClient.prefetchQuery<${componentName}
|
|
573
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
562
574
|
|
|
563
575
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
564
576
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
565
|
-
queryClient.invalidateQueries<${componentName}
|
|
577
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
566
578
|
|
|
567
|
-
export function use${componentName}Query<T = ${componentName}
|
|
579
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>}) {
|
|
568
580
|
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
569
581
|
{ enabled: ${enabledParam}, ...options }
|
|
570
582
|
);}
|
|
571
583
|
|
|
572
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
584
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: { options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>}) {
|
|
573
585
|
return useMutation(async (data) => use${componentName}Query.fetch(data),
|
|
574
586
|
props?.options
|
|
575
587
|
)};
|
|
@@ -577,11 +589,12 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
577
589
|
}
|
|
578
590
|
if (requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
|
|
579
591
|
output += `
|
|
580
|
-
|
|
592
|
+
// type5
|
|
593
|
+
type ${componentName}Return = ${genericsTypes}
|
|
581
594
|
type ${componentName}Variables = ${requestBodyComponent};
|
|
582
595
|
|
|
583
596
|
use${componentName}Query.fetch = async (body: ${componentName}Variables) => {
|
|
584
|
-
const result = await api.${verb}<${componentName}
|
|
597
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}\`, body)
|
|
585
598
|
return result.data
|
|
586
599
|
}
|
|
587
600
|
|
|
@@ -590,48 +603,51 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
590
603
|
|
|
591
604
|
use${componentName}Query.updateCache = (
|
|
592
605
|
params: ${componentName}Variables,
|
|
593
|
-
updater: Updater<${componentName}
|
|
606
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
594
607
|
options?: SetDataOptions | undefined
|
|
595
|
-
) => queryClient.setQueryData<${componentName}
|
|
608
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
596
609
|
|
|
597
610
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
598
|
-
queryClient.prefetchQuery<${componentName}
|
|
611
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
599
612
|
|
|
600
613
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
601
614
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
602
|
-
queryClient.invalidateQueries<${componentName}
|
|
615
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
603
616
|
|
|
604
617
|
|
|
605
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
606
|
-
options?: UseQueryOptions<${componentName}
|
|
618
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
619
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
607
620
|
}
|
|
608
|
-
export function use${componentName}Query<T = ${componentName}
|
|
621
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
|
|
609
622
|
return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body), options
|
|
610
623
|
);}
|
|
611
624
|
|
|
612
625
|
type ${componentName}MutationProps<T> = {
|
|
613
|
-
options?: UseMutationOptions<${componentName}
|
|
626
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
614
627
|
}
|
|
615
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
628
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
616
629
|
return useMutation(async (body) => use${componentName}Query.fetch(body),
|
|
617
630
|
props?.options
|
|
618
631
|
)};`;
|
|
619
632
|
}
|
|
620
633
|
if (requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
|
|
621
634
|
output += `
|
|
622
|
-
|
|
635
|
+
import queryString from 'query-string';
|
|
636
|
+
|
|
637
|
+
// type6
|
|
638
|
+
type ${componentName}Return = ${genericsTypes}
|
|
623
639
|
type ${componentName}Variables = {
|
|
624
640
|
body: ${requestBodyComponent}
|
|
625
641
|
${paramsTypes}
|
|
626
642
|
}
|
|
627
643
|
|
|
628
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
629
|
-
options?: UseQueryOptions<${componentName}
|
|
644
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
645
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
630
646
|
}
|
|
631
647
|
|
|
632
648
|
use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
|
|
633
649
|
const {${paramsInPath.join(', ')}, ...body} = props
|
|
634
|
-
const result = await api.${verb}<${componentName}
|
|
650
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}\`, body)
|
|
635
651
|
return result.data
|
|
636
652
|
}
|
|
637
653
|
use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
|
|
@@ -639,48 +655,51 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
639
655
|
|
|
640
656
|
use${componentName}Query.updateCache = (
|
|
641
657
|
params: ${componentName}Variables,
|
|
642
|
-
updater: Updater<${componentName}
|
|
658
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
643
659
|
options?: SetDataOptions | undefined
|
|
644
|
-
) => queryClient.setQueryData<${componentName}
|
|
660
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
645
661
|
|
|
646
662
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
647
|
-
queryClient.prefetchQuery<${componentName}
|
|
663
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
648
664
|
|
|
649
665
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
650
666
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
651
|
-
queryClient.invalidateQueries<${componentName}
|
|
667
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
652
668
|
|
|
653
669
|
|
|
654
|
-
export function use${componentName}Query<T = ${componentName}
|
|
655
|
-
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
656
|
-
|
|
670
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
671
|
+
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
672
|
+
{ enabled: ${enabledParam}, ...options }
|
|
657
673
|
);}
|
|
658
674
|
|
|
659
675
|
type ${componentName}MutationProps<T> = {
|
|
660
|
-
options?: UseMutationOptions<${componentName}
|
|
676
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
661
677
|
}
|
|
662
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
678
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
663
679
|
return useMutation(async (body) => use${componentName}Query.fetch(body),
|
|
664
680
|
props?.options
|
|
665
681
|
)};`;
|
|
666
682
|
}
|
|
667
683
|
if (requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
|
|
668
684
|
output += `
|
|
669
|
-
|
|
685
|
+
import queryString from 'query-string';
|
|
686
|
+
|
|
687
|
+
// type7
|
|
688
|
+
type ${componentName}Return = ${genericsTypes}
|
|
670
689
|
type ${componentName}Variables = {
|
|
671
690
|
body: ${requestBodyComponent}
|
|
672
691
|
${queryParamsType}
|
|
673
692
|
}
|
|
674
693
|
|
|
675
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
676
|
-
options?: UseQueryOptions<${componentName}
|
|
694
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
695
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
677
696
|
}
|
|
678
697
|
|
|
679
698
|
use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
|
|
680
699
|
const params = queryString.stringify({
|
|
681
700
|
${queryParams.map((param) => `["${param.name}"]: props["${param.name}"]`).join(',')}
|
|
682
701
|
});
|
|
683
|
-
const result = await api.${verb}<${componentName}
|
|
702
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`, props.body)
|
|
684
703
|
return result.data
|
|
685
704
|
}
|
|
686
705
|
use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
|
|
@@ -688,28 +707,28 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
688
707
|
|
|
689
708
|
use${componentName}Query.updateCache = (
|
|
690
709
|
params: ${componentName}Variables,
|
|
691
|
-
updater: Updater<${componentName}
|
|
710
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
692
711
|
options?: SetDataOptions | undefined
|
|
693
|
-
) => queryClient.setQueryData<${componentName}
|
|
712
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
694
713
|
|
|
695
714
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
696
|
-
queryClient.prefetchQuery<${componentName}
|
|
715
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
697
716
|
|
|
698
717
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
699
718
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
700
|
-
queryClient.invalidateQueries<${componentName}
|
|
719
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
701
720
|
|
|
702
721
|
|
|
703
|
-
export function use${componentName}Query<T = ${componentName}
|
|
704
|
-
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
705
|
-
|
|
722
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
723
|
+
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
724
|
+
{ enabled: ${enabledParam}, ...options }
|
|
706
725
|
);}
|
|
707
726
|
|
|
708
727
|
|
|
709
728
|
type ${componentName}MutationProps<T> = {
|
|
710
|
-
options?: UseMutationOptions<${componentName}
|
|
729
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
711
730
|
}
|
|
712
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
731
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
713
732
|
return useMutation(async (body) => use${componentName}Query.fetch(body),
|
|
714
733
|
props?.options
|
|
715
734
|
)};`;
|
|
@@ -731,13 +750,13 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
731
750
|
}
|
|
732
751
|
if (!requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
|
|
733
752
|
output += `
|
|
734
|
-
type ${componentName}
|
|
753
|
+
type ${componentName}Return = ${genericsTypes}
|
|
735
754
|
type ${componentName}Variables = {
|
|
736
755
|
${headerParam}
|
|
737
756
|
};
|
|
738
757
|
|
|
739
758
|
use${componentName}Query.fetch = async (headers: ${componentName}Variables) => {
|
|
740
|
-
const result = await api.${verb}<${componentName}
|
|
759
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}\`, {headers: headers});
|
|
741
760
|
return result.data;
|
|
742
761
|
}
|
|
743
762
|
|
|
@@ -746,39 +765,39 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
746
765
|
|
|
747
766
|
use${componentName}Query.updateCache = (
|
|
748
767
|
params: ${componentName}Variables,
|
|
749
|
-
updater: Updater<${componentName}
|
|
768
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
750
769
|
options?: SetDataOptions | undefined
|
|
751
|
-
) => queryClient.setQueryData<${componentName}
|
|
770
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
752
771
|
|
|
753
772
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
754
|
-
queryClient.prefetchQuery<${componentName}
|
|
773
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
755
774
|
|
|
756
775
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
757
776
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
758
|
-
queryClient.invalidateQueries<${componentName}
|
|
777
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
759
778
|
|
|
760
779
|
|
|
761
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
762
|
-
options?: UseQueryOptions<${componentName}
|
|
780
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
781
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
763
782
|
}
|
|
764
|
-
export function use${componentName}Query<T = ${componentName}
|
|
783
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
765
784
|
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
766
785
|
{ enabled: ${enabledParam}, ...options }
|
|
767
786
|
);}
|
|
768
787
|
|
|
769
|
-
|
|
770
|
-
|
|
771
788
|
type ${componentName}MutationProps<T> = {
|
|
772
|
-
options?: UseMutationOptions<${componentName}
|
|
789
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
773
790
|
}
|
|
774
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
791
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
775
792
|
return useMutation(async (data) => use${componentName}Query.fetch(data),
|
|
776
793
|
props?.options
|
|
777
794
|
)};`;
|
|
778
795
|
}
|
|
779
796
|
if (!requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
|
|
780
797
|
output += `
|
|
781
|
-
|
|
798
|
+
import queryString from 'query-string';
|
|
799
|
+
|
|
800
|
+
type ${componentName}Return = ${genericsTypes}
|
|
782
801
|
|
|
783
802
|
type ${componentName}Variables = {
|
|
784
803
|
${headerParam}
|
|
@@ -792,7 +811,7 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
792
811
|
const headers = {
|
|
793
812
|
${headerParams.map((p) => `"${p.name}": data["${p.name}"]`).join(',')}
|
|
794
813
|
}
|
|
795
|
-
const result = await api.${verb}<${componentName}
|
|
814
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`, {headers})
|
|
796
815
|
return result.data;
|
|
797
816
|
}
|
|
798
817
|
use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
|
|
@@ -800,37 +819,37 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
800
819
|
|
|
801
820
|
use${componentName}Query.updateCache = (
|
|
802
821
|
params: ${componentName}Variables,
|
|
803
|
-
updater: Updater<${componentName}
|
|
822
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
804
823
|
options?: SetDataOptions | undefined
|
|
805
|
-
) => queryClient.setQueryData<${componentName}
|
|
824
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
806
825
|
|
|
807
826
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
808
|
-
queryClient.prefetchQuery<${componentName}
|
|
827
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
809
828
|
|
|
810
829
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
811
830
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
812
|
-
queryClient.invalidateQueries<${componentName}
|
|
831
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
813
832
|
|
|
814
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
815
|
-
options?: UseQueryOptions<${componentName}
|
|
833
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
834
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
816
835
|
}
|
|
817
|
-
export function use${componentName}Query<T = ${componentName}
|
|
836
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
818
837
|
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
819
838
|
{ enabled: ${enabledParam}, ...options }
|
|
820
839
|
);}
|
|
821
840
|
|
|
822
841
|
type ${componentName}MutationProps<T> = {
|
|
823
|
-
options?: UseMutationOptions<${componentName}
|
|
842
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
824
843
|
}
|
|
825
844
|
|
|
826
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
845
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
827
846
|
return useMutation(async (data) => use${componentName}Query.fetch(data),
|
|
828
847
|
props?.options
|
|
829
848
|
)};`;
|
|
830
849
|
}
|
|
831
850
|
if (requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
|
|
832
851
|
output += `
|
|
833
|
-
type ${componentName}
|
|
852
|
+
type ${componentName}Return = ${genericsTypes}
|
|
834
853
|
|
|
835
854
|
type ${componentName}Variables = {
|
|
836
855
|
body: ${requestBodyComponent}
|
|
@@ -841,7 +860,7 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
841
860
|
const headers = {
|
|
842
861
|
${headerParams.map((param) => `"${param.name}": body["${param.name}"]`).join(',')}
|
|
843
862
|
}
|
|
844
|
-
const result = await api.${verb}<${componentName}
|
|
863
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}\`, body, {headers})
|
|
845
864
|
return result.data
|
|
846
865
|
}
|
|
847
866
|
|
|
@@ -850,30 +869,30 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
|
|
|
850
869
|
|
|
851
870
|
use${componentName}Query.updateCache = (
|
|
852
871
|
params: ${componentName}Variables,
|
|
853
|
-
updater: Updater<${componentName}
|
|
872
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
854
873
|
options?: SetDataOptions | undefined
|
|
855
|
-
) => queryClient.setQueryData<${componentName}
|
|
874
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
856
875
|
|
|
857
876
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
858
|
-
queryClient.prefetchQuery<${componentName}
|
|
877
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
859
878
|
|
|
860
879
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
861
880
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
862
|
-
queryClient.invalidateQueries<${componentName}
|
|
881
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
863
882
|
|
|
864
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
865
|
-
options?: UseQueryOptions<${componentName}
|
|
883
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
884
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
866
885
|
}
|
|
867
|
-
export function use${componentName}Query<T = ${componentName}
|
|
868
|
-
return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body),
|
|
869
|
-
|
|
870
|
-
|
|
886
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
|
|
887
|
+
return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body),
|
|
888
|
+
{ enabled: ${enabledParam}, ...options }
|
|
889
|
+
);}
|
|
871
890
|
|
|
872
891
|
|
|
873
892
|
type ${componentName}MutationProps<T> = {
|
|
874
|
-
options?: UseMutationOptions<${componentName}
|
|
893
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
875
894
|
}
|
|
876
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
895
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
877
896
|
return useMutation(async (body) => use${componentName}Query.fetch(body),
|
|
878
897
|
props?.options
|
|
879
898
|
)};`;
|
|
@@ -923,7 +942,6 @@ const importOpenApi = async ({ data, format, apiDirectory, queryClientDir, heade
|
|
|
923
942
|
} from 'react-query';
|
|
924
943
|
import { Updater } from 'react-query/types/core/utils';
|
|
925
944
|
|
|
926
|
-
import queryString from 'query-string';
|
|
927
945
|
import { AxiosError } from 'axios';
|
|
928
946
|
import { api } from '${apiDirectory}';
|
|
929
947
|
import { queryClient } from '${queryClientDir}';
|
|
@@ -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
|
|
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
|
|
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)} *
|
|
294
|
+
.map((i) => `${' '.repeat(tabSize)} * ${i}`)
|
|
292
295
|
.join('\n')}\n${' '.repeat(tabSize)} */${' '.repeat(tabSize)}`
|
|
293
296
|
: '';
|
|
294
297
|
/**
|
|
@@ -386,13 +389,14 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
386
389
|
// QUERIES
|
|
387
390
|
if (!requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
|
|
388
391
|
output += `
|
|
389
|
-
|
|
392
|
+
// type1
|
|
393
|
+
type ${componentName}Return = ${genericsTypes}
|
|
390
394
|
type ${componentName}Variables = {
|
|
391
395
|
${paramsTypes}
|
|
392
396
|
}
|
|
393
397
|
|
|
394
398
|
use${componentName}Query.fetch = async (props: ${componentName}Variables ) => {
|
|
395
|
-
const result = await api.${verb}<${componentName}
|
|
399
|
+
const result = await api.${verb}<${componentName}Return>(\`${route.replace(/\{/g, '{props.')}\`);
|
|
396
400
|
return result.data;
|
|
397
401
|
}
|
|
398
402
|
use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
|
|
@@ -400,36 +404,39 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
400
404
|
|
|
401
405
|
use${componentName}Query.updateCache = (
|
|
402
406
|
params: ${componentName}Variables,
|
|
403
|
-
updater: Updater<${componentName}
|
|
407
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
404
408
|
options?: SetDataOptions | undefined
|
|
405
|
-
) => queryClient.setQueryData<${componentName}
|
|
409
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
406
410
|
|
|
407
411
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
408
|
-
queryClient.prefetchQuery<${componentName}
|
|
412
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
409
413
|
|
|
410
414
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
411
415
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
412
|
-
queryClient.invalidateQueries<${componentName}
|
|
416
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
413
417
|
|
|
414
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
415
|
-
options?: UseQueryOptions<${componentName}
|
|
418
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
419
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
416
420
|
}
|
|
417
|
-
export function use${componentName}Query<T = ${componentName}
|
|
421
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
418
422
|
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
419
423
|
{ enabled: ${enabledParam}, ...options }
|
|
420
|
-
|
|
424
|
+
);}
|
|
421
425
|
|
|
422
426
|
type ${componentName}MutationProps<T> = {
|
|
423
|
-
options?: UseMutationOptions<${componentName}
|
|
427
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
424
428
|
}
|
|
425
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
429
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
426
430
|
return useMutation(async (data) => use${componentName}Query.fetch(data),
|
|
427
431
|
props?.options
|
|
428
432
|
)};`;
|
|
429
433
|
}
|
|
430
434
|
if (!requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
|
|
431
435
|
output += `
|
|
432
|
-
|
|
436
|
+
import queryString from 'query-string';
|
|
437
|
+
|
|
438
|
+
// type2
|
|
439
|
+
type ${componentName}Return = ${genericsTypes}
|
|
433
440
|
type ${componentName}Variables = {
|
|
434
441
|
${paramsTypes}
|
|
435
442
|
${queryParamsType};
|
|
@@ -438,7 +445,7 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
438
445
|
use${componentName}Query.fetch = async (props:${componentName}Variables) => {
|
|
439
446
|
const {${paramsInPath.join(', ')}, ...queryParams} = props
|
|
440
447
|
const params = queryString.stringify(queryParams);
|
|
441
|
-
const result = await api.${verb}<${componentName}
|
|
448
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`)
|
|
442
449
|
return result.data;
|
|
443
450
|
}
|
|
444
451
|
|
|
@@ -447,38 +454,39 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
447
454
|
|
|
448
455
|
use${componentName}Query.updateCache = (
|
|
449
456
|
params: ${componentName}Variables,
|
|
450
|
-
updater: Updater<${componentName}
|
|
457
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
451
458
|
options?: SetDataOptions | undefined
|
|
452
|
-
) => queryClient.setQueryData<${componentName}
|
|
459
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
453
460
|
|
|
454
461
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
455
|
-
queryClient.prefetchQuery<${componentName}
|
|
462
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
456
463
|
|
|
457
464
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
458
465
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
459
|
-
queryClient.invalidateQueries<${componentName}
|
|
466
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
460
467
|
|
|
461
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
462
|
-
options?: UseQueryOptions<${componentName}
|
|
468
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
469
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
463
470
|
}
|
|
464
|
-
export function use${componentName}Query<T = ${componentName}
|
|
465
|
-
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
466
|
-
|
|
471
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
472
|
+
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
473
|
+
{ enabled: ${enabledParam}, ...options }
|
|
467
474
|
);}
|
|
468
475
|
|
|
469
476
|
type ${componentName}MutationProps<T> = {
|
|
470
|
-
options?: UseMutationOptions<${componentName}
|
|
477
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
471
478
|
}
|
|
472
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
479
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
473
480
|
return useMutation(async (data) => use${componentName}Query.fetch(data),
|
|
474
481
|
props?.options
|
|
475
482
|
)};`;
|
|
476
483
|
}
|
|
477
484
|
if (!requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
|
|
478
485
|
output += `
|
|
479
|
-
|
|
486
|
+
// type3
|
|
487
|
+
type ${componentName}Return = ${genericsTypes}
|
|
480
488
|
use${componentName}Query.fetch = async () => {
|
|
481
|
-
const result = await api.${verb}<${componentName}
|
|
489
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}\`);
|
|
482
490
|
return result.data;
|
|
483
491
|
}
|
|
484
492
|
use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
|
|
@@ -486,36 +494,40 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
486
494
|
|
|
487
495
|
use${componentName}Query.updateCache = (
|
|
488
496
|
params: undefined,
|
|
489
|
-
updater: Updater<${componentName}
|
|
497
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
490
498
|
options?: SetDataOptions | undefined
|
|
491
|
-
) => queryClient.setQueryData<${componentName}
|
|
499
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(), updater, options);
|
|
492
500
|
|
|
493
501
|
use${componentName}Query.prefetch = () =>
|
|
494
|
-
queryClient.prefetchQuery<${componentName}
|
|
502
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(), ()=> use${componentName}Query.fetch());
|
|
495
503
|
|
|
496
504
|
use${componentName}Query.cancelQueries = () => queryClient.cancelQueries(use${componentName}Query.queryKey())
|
|
497
505
|
use${componentName}Query.invalidate = () =>
|
|
498
|
-
queryClient.invalidateQueries<${componentName}
|
|
506
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey());
|
|
499
507
|
|
|
500
508
|
|
|
501
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
502
|
-
options?: UseQueryOptions<${componentName}
|
|
509
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = {
|
|
510
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
503
511
|
}
|
|
504
|
-
export function use${componentName}Query<T = ${componentName}
|
|
512
|
+
export function use${componentName}Query<T = ${componentName}Return>(props?: ${componentName}QueryProps<T>) {
|
|
505
513
|
return useQuery(use${componentName}Query.queryKey(), use${componentName}Query.fetch, props?.options
|
|
506
514
|
);}
|
|
507
515
|
|
|
508
516
|
type ${componentName}MutationProps<T> = {
|
|
509
|
-
options?: UseMutationOptions<${componentName}
|
|
517
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, void, T>
|
|
510
518
|
}
|
|
511
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
519
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
512
520
|
return useMutation(async () => use${componentName}Query.fetch(),
|
|
513
521
|
props?.options
|
|
514
522
|
)};`;
|
|
515
523
|
}
|
|
516
524
|
if (!requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
|
|
517
525
|
output += `
|
|
518
|
-
|
|
526
|
+
// type4
|
|
527
|
+
import queryString from 'query-string';
|
|
528
|
+
|
|
529
|
+
|
|
530
|
+
type ${componentName}Return = ${genericsTypes}
|
|
519
531
|
type ${componentName}Variables = {
|
|
520
532
|
${queryParamsType}
|
|
521
533
|
}
|
|
@@ -524,7 +536,7 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
524
536
|
const params = queryString.stringify({${queryParams
|
|
525
537
|
.map((param) => `"${param.name}": props["${param.name}"]`)
|
|
526
538
|
.join(',')}});
|
|
527
|
-
const result = await api.${verb}<${componentName}
|
|
539
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`)
|
|
528
540
|
return result.data;
|
|
529
541
|
}
|
|
530
542
|
|
|
@@ -533,23 +545,23 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
533
545
|
|
|
534
546
|
use${componentName}Query.updateCache = (
|
|
535
547
|
params: ${componentName}Variables,
|
|
536
|
-
updater: Updater<${componentName}
|
|
548
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
537
549
|
options?: SetDataOptions | undefined
|
|
538
|
-
) => queryClient.setQueryData<${componentName}
|
|
550
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
539
551
|
|
|
540
552
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
541
|
-
queryClient.prefetchQuery<${componentName}
|
|
553
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
542
554
|
|
|
543
555
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
544
556
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
545
|
-
queryClient.invalidateQueries<${componentName}
|
|
557
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
546
558
|
|
|
547
|
-
export function use${componentName}Query<T = ${componentName}
|
|
559
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>}) {
|
|
548
560
|
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
549
561
|
{ enabled: ${enabledParam}, ...options }
|
|
550
562
|
);}
|
|
551
563
|
|
|
552
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
564
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: { options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>}) {
|
|
553
565
|
return useMutation(async (data) => use${componentName}Query.fetch(data),
|
|
554
566
|
props?.options
|
|
555
567
|
)};
|
|
@@ -557,11 +569,12 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
557
569
|
}
|
|
558
570
|
if (requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
|
|
559
571
|
output += `
|
|
560
|
-
|
|
572
|
+
// type5
|
|
573
|
+
type ${componentName}Return = ${genericsTypes}
|
|
561
574
|
type ${componentName}Variables = ${requestBodyComponent};
|
|
562
575
|
|
|
563
576
|
use${componentName}Query.fetch = async (body: ${componentName}Variables) => {
|
|
564
|
-
const result = await api.${verb}<${componentName}
|
|
577
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}\`, body)
|
|
565
578
|
return result.data
|
|
566
579
|
}
|
|
567
580
|
|
|
@@ -570,48 +583,51 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
570
583
|
|
|
571
584
|
use${componentName}Query.updateCache = (
|
|
572
585
|
params: ${componentName}Variables,
|
|
573
|
-
updater: Updater<${componentName}
|
|
586
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
574
587
|
options?: SetDataOptions | undefined
|
|
575
|
-
) => queryClient.setQueryData<${componentName}
|
|
588
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
576
589
|
|
|
577
590
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
578
|
-
queryClient.prefetchQuery<${componentName}
|
|
591
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
579
592
|
|
|
580
593
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
581
594
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
582
|
-
queryClient.invalidateQueries<${componentName}
|
|
595
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
583
596
|
|
|
584
597
|
|
|
585
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
586
|
-
options?: UseQueryOptions<${componentName}
|
|
598
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
599
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
587
600
|
}
|
|
588
|
-
export function use${componentName}Query<T = ${componentName}
|
|
601
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
|
|
589
602
|
return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body), options
|
|
590
603
|
);}
|
|
591
604
|
|
|
592
605
|
type ${componentName}MutationProps<T> = {
|
|
593
|
-
options?: UseMutationOptions<${componentName}
|
|
606
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
594
607
|
}
|
|
595
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
608
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
596
609
|
return useMutation(async (body) => use${componentName}Query.fetch(body),
|
|
597
610
|
props?.options
|
|
598
611
|
)};`;
|
|
599
612
|
}
|
|
600
613
|
if (requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
|
|
601
614
|
output += `
|
|
602
|
-
|
|
615
|
+
import queryString from 'query-string';
|
|
616
|
+
|
|
617
|
+
// type6
|
|
618
|
+
type ${componentName}Return = ${genericsTypes}
|
|
603
619
|
type ${componentName}Variables = {
|
|
604
620
|
body: ${requestBodyComponent}
|
|
605
621
|
${paramsTypes}
|
|
606
622
|
}
|
|
607
623
|
|
|
608
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
609
|
-
options?: UseQueryOptions<${componentName}
|
|
624
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
625
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
610
626
|
}
|
|
611
627
|
|
|
612
628
|
use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
|
|
613
629
|
const {${paramsInPath.join(', ')}, ...body} = props
|
|
614
|
-
const result = await api.${verb}<${componentName}
|
|
630
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}\`, body)
|
|
615
631
|
return result.data
|
|
616
632
|
}
|
|
617
633
|
use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
|
|
@@ -619,48 +635,51 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
619
635
|
|
|
620
636
|
use${componentName}Query.updateCache = (
|
|
621
637
|
params: ${componentName}Variables,
|
|
622
|
-
updater: Updater<${componentName}
|
|
638
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
623
639
|
options?: SetDataOptions | undefined
|
|
624
|
-
) => queryClient.setQueryData<${componentName}
|
|
640
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
625
641
|
|
|
626
642
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
627
|
-
queryClient.prefetchQuery<${componentName}
|
|
643
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
628
644
|
|
|
629
645
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
630
646
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
631
|
-
queryClient.invalidateQueries<${componentName}
|
|
647
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
632
648
|
|
|
633
649
|
|
|
634
|
-
export function use${componentName}Query<T = ${componentName}
|
|
635
|
-
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
636
|
-
|
|
650
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
651
|
+
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
652
|
+
{ enabled: ${enabledParam}, ...options }
|
|
637
653
|
);}
|
|
638
654
|
|
|
639
655
|
type ${componentName}MutationProps<T> = {
|
|
640
|
-
options?: UseMutationOptions<${componentName}
|
|
656
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
641
657
|
}
|
|
642
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
658
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
643
659
|
return useMutation(async (body) => use${componentName}Query.fetch(body),
|
|
644
660
|
props?.options
|
|
645
661
|
)};`;
|
|
646
662
|
}
|
|
647
663
|
if (requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
|
|
648
664
|
output += `
|
|
649
|
-
|
|
665
|
+
import queryString from 'query-string';
|
|
666
|
+
|
|
667
|
+
// type7
|
|
668
|
+
type ${componentName}Return = ${genericsTypes}
|
|
650
669
|
type ${componentName}Variables = {
|
|
651
670
|
body: ${requestBodyComponent}
|
|
652
671
|
${queryParamsType}
|
|
653
672
|
}
|
|
654
673
|
|
|
655
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
656
|
-
options?: UseQueryOptions<${componentName}
|
|
674
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
675
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
657
676
|
}
|
|
658
677
|
|
|
659
678
|
use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
|
|
660
679
|
const params = queryString.stringify({
|
|
661
680
|
${queryParams.map((param) => `["${param.name}"]: props["${param.name}"]`).join(',')}
|
|
662
681
|
});
|
|
663
|
-
const result = await api.${verb}<${componentName}
|
|
682
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`, props.body)
|
|
664
683
|
return result.data
|
|
665
684
|
}
|
|
666
685
|
use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
|
|
@@ -668,28 +687,28 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
668
687
|
|
|
669
688
|
use${componentName}Query.updateCache = (
|
|
670
689
|
params: ${componentName}Variables,
|
|
671
|
-
updater: Updater<${componentName}
|
|
690
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
672
691
|
options?: SetDataOptions | undefined
|
|
673
|
-
) => queryClient.setQueryData<${componentName}
|
|
692
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
674
693
|
|
|
675
694
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
676
|
-
queryClient.prefetchQuery<${componentName}
|
|
695
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
677
696
|
|
|
678
697
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
679
698
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
680
|
-
queryClient.invalidateQueries<${componentName}
|
|
699
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
681
700
|
|
|
682
701
|
|
|
683
|
-
export function use${componentName}Query<T = ${componentName}
|
|
684
|
-
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
685
|
-
|
|
702
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
703
|
+
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
704
|
+
{ enabled: ${enabledParam}, ...options }
|
|
686
705
|
);}
|
|
687
706
|
|
|
688
707
|
|
|
689
708
|
type ${componentName}MutationProps<T> = {
|
|
690
|
-
options?: UseMutationOptions<${componentName}
|
|
709
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
691
710
|
}
|
|
692
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
711
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
693
712
|
return useMutation(async (body) => use${componentName}Query.fetch(body),
|
|
694
713
|
props?.options
|
|
695
714
|
)};`;
|
|
@@ -711,13 +730,13 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
711
730
|
}
|
|
712
731
|
if (!requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
|
|
713
732
|
output += `
|
|
714
|
-
type ${componentName}
|
|
733
|
+
type ${componentName}Return = ${genericsTypes}
|
|
715
734
|
type ${componentName}Variables = {
|
|
716
735
|
${headerParam}
|
|
717
736
|
};
|
|
718
737
|
|
|
719
738
|
use${componentName}Query.fetch = async (headers: ${componentName}Variables) => {
|
|
720
|
-
const result = await api.${verb}<${componentName}
|
|
739
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}\`, {headers: headers});
|
|
721
740
|
return result.data;
|
|
722
741
|
}
|
|
723
742
|
|
|
@@ -726,39 +745,39 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
726
745
|
|
|
727
746
|
use${componentName}Query.updateCache = (
|
|
728
747
|
params: ${componentName}Variables,
|
|
729
|
-
updater: Updater<${componentName}
|
|
748
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
730
749
|
options?: SetDataOptions | undefined
|
|
731
|
-
) => queryClient.setQueryData<${componentName}
|
|
750
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
732
751
|
|
|
733
752
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
734
|
-
queryClient.prefetchQuery<${componentName}
|
|
753
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
735
754
|
|
|
736
755
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
737
756
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
738
|
-
queryClient.invalidateQueries<${componentName}
|
|
757
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
739
758
|
|
|
740
759
|
|
|
741
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
742
|
-
options?: UseQueryOptions<${componentName}
|
|
760
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
761
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
743
762
|
}
|
|
744
|
-
export function use${componentName}Query<T = ${componentName}
|
|
763
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
745
764
|
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
746
765
|
{ enabled: ${enabledParam}, ...options }
|
|
747
766
|
);}
|
|
748
767
|
|
|
749
|
-
|
|
750
|
-
|
|
751
768
|
type ${componentName}MutationProps<T> = {
|
|
752
|
-
options?: UseMutationOptions<${componentName}
|
|
769
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
753
770
|
}
|
|
754
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
771
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
755
772
|
return useMutation(async (data) => use${componentName}Query.fetch(data),
|
|
756
773
|
props?.options
|
|
757
774
|
)};`;
|
|
758
775
|
}
|
|
759
776
|
if (!requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
|
|
760
777
|
output += `
|
|
761
|
-
|
|
778
|
+
import queryString from 'query-string';
|
|
779
|
+
|
|
780
|
+
type ${componentName}Return = ${genericsTypes}
|
|
762
781
|
|
|
763
782
|
type ${componentName}Variables = {
|
|
764
783
|
${headerParam}
|
|
@@ -772,7 +791,7 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
772
791
|
const headers = {
|
|
773
792
|
${headerParams.map((p) => `"${p.name}": data["${p.name}"]`).join(',')}
|
|
774
793
|
}
|
|
775
|
-
const result = await api.${verb}<${componentName}
|
|
794
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}?\${params}\`, {headers})
|
|
776
795
|
return result.data;
|
|
777
796
|
}
|
|
778
797
|
use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
|
|
@@ -780,37 +799,37 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
780
799
|
|
|
781
800
|
use${componentName}Query.updateCache = (
|
|
782
801
|
params: ${componentName}Variables,
|
|
783
|
-
updater: Updater<${componentName}
|
|
802
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
784
803
|
options?: SetDataOptions | undefined
|
|
785
|
-
) => queryClient.setQueryData<${componentName}
|
|
804
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
786
805
|
|
|
787
806
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
788
|
-
queryClient.prefetchQuery<${componentName}
|
|
807
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
789
808
|
|
|
790
809
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
791
810
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
792
|
-
queryClient.invalidateQueries<${componentName}
|
|
811
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
793
812
|
|
|
794
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
795
|
-
options?: UseQueryOptions<${componentName}
|
|
813
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
814
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
796
815
|
}
|
|
797
|
-
export function use${componentName}Query<T = ${componentName}
|
|
816
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
|
|
798
817
|
return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
|
|
799
818
|
{ enabled: ${enabledParam}, ...options }
|
|
800
819
|
);}
|
|
801
820
|
|
|
802
821
|
type ${componentName}MutationProps<T> = {
|
|
803
|
-
options?: UseMutationOptions<${componentName}
|
|
822
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
804
823
|
}
|
|
805
824
|
|
|
806
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
825
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
807
826
|
return useMutation(async (data) => use${componentName}Query.fetch(data),
|
|
808
827
|
props?.options
|
|
809
828
|
)};`;
|
|
810
829
|
}
|
|
811
830
|
if (requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
|
|
812
831
|
output += `
|
|
813
|
-
type ${componentName}
|
|
832
|
+
type ${componentName}Return = ${genericsTypes}
|
|
814
833
|
|
|
815
834
|
type ${componentName}Variables = {
|
|
816
835
|
body: ${requestBodyComponent}
|
|
@@ -821,7 +840,7 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
821
840
|
const headers = {
|
|
822
841
|
${headerParams.map((param) => `"${param.name}": body["${param.name}"]`).join(',')}
|
|
823
842
|
}
|
|
824
|
-
const result = await api.${verb}<${componentName}
|
|
843
|
+
const result = await api.${verb}<${componentName}Return>(\`${route}\`, body, {headers})
|
|
825
844
|
return result.data
|
|
826
845
|
}
|
|
827
846
|
|
|
@@ -830,30 +849,30 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
|
|
|
830
849
|
|
|
831
850
|
use${componentName}Query.updateCache = (
|
|
832
851
|
params: ${componentName}Variables,
|
|
833
|
-
updater: Updater<${componentName}
|
|
852
|
+
updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
|
|
834
853
|
options?: SetDataOptions | undefined
|
|
835
|
-
) => queryClient.setQueryData<${componentName}
|
|
854
|
+
) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
|
|
836
855
|
|
|
837
856
|
use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
|
|
838
|
-
queryClient.prefetchQuery<${componentName}
|
|
857
|
+
queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
|
|
839
858
|
|
|
840
859
|
use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
|
|
841
860
|
use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
|
|
842
|
-
queryClient.invalidateQueries<${componentName}
|
|
861
|
+
queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
|
|
843
862
|
|
|
844
|
-
type ${componentName}QueryProps<T = ${componentName}
|
|
845
|
-
options?: UseQueryOptions<${componentName}
|
|
863
|
+
type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
|
|
864
|
+
options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>
|
|
846
865
|
}
|
|
847
|
-
export function use${componentName}Query<T = ${componentName}
|
|
848
|
-
return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body),
|
|
849
|
-
|
|
850
|
-
|
|
866
|
+
export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
|
|
867
|
+
return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body),
|
|
868
|
+
{ enabled: ${enabledParam}, ...options }
|
|
869
|
+
);}
|
|
851
870
|
|
|
852
871
|
|
|
853
872
|
type ${componentName}MutationProps<T> = {
|
|
854
|
-
options?: UseMutationOptions<${componentName}
|
|
873
|
+
options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
|
|
855
874
|
}
|
|
856
|
-
export function use${componentName}Mutation<T = ${componentName}
|
|
875
|
+
export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
|
|
857
876
|
return useMutation(async (body) => use${componentName}Query.fetch(body),
|
|
858
877
|
props?.options
|
|
859
878
|
)};`;
|
|
@@ -902,7 +921,6 @@ export const importOpenApi = async ({ data, format, apiDirectory, queryClientDir
|
|
|
902
921
|
} from 'react-query';
|
|
903
922
|
import { Updater } from 'react-query/types/core/utils';
|
|
904
923
|
|
|
905
|
-
import queryString from 'query-string';
|
|
906
924
|
import { AxiosError } from 'axios';
|
|
907
925
|
import { api } from '${apiDirectory}';
|
|
908
926
|
import { queryClient } from '${queryClientDir}';
|