npm - react-query-lightbase-codegen - Versions diffs - 0.1.5 → 0.1.8 - Mend

react-query-lightbase-codegen 0.1.5 → 0.1.8

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 (7) hide show

package/lib/cjs/import-open-api.js +68 -30
package/lib/esm/import-open-api.js +68 -30
package/package.json +1 -1
package/lib/bin/react-query-codegen-import.js +0 -39
package/lib/bin/react-query-codegen.js +0 -8
package/lib/scripts/import-open-api.js +0 -605
package/lib/types.js +0 -1

package/lib/cjs/import-open-api.js CHANGED Viewed

@@ -140,7 +140,7 @@ const getObject = (item) => {
         if (item.properties) {
             output += '\n';
         }
-        output += `  [key: string]: ${item.additionalProperties === true ? 'any' : (0, exports.resolveValue)(item.additionalProperties)};`;
+        output += `} & { [key: string]: ${item.additionalProperties === true ? 'any' : (0, exports.resolveValue)(item.additionalProperties)}`;
     }
     if (item.properties || item.additionalProperties) {
         if (output === '{\n') {
@@ -205,7 +205,7 @@ const generateInterface = (name, schema) => {
     const scalar = (0, exports.getScalar)(schema);
     return `
     ${(0, exports.formatDescription)(schema.description)}
-    export interface ${(0, case_1.pascal)(name)} ${scalar}
+    export type ${(0, case_1.pascal)(name)} = ${scalar}
   `;
 };
 exports.generateInterface = generateInterface;
@@ -264,10 +264,10 @@ const generateRequestBodiesDefinition = (requestBodies = {}) => {
             const type = (0, exports.getResReqTypes)([['', requestBody]]);
             const isEmptyInterface = type === '{}';
             if (isEmptyInterface) {
-                return `export interface ${(0, case_1.pascal)(name)}RequestBody ${type}`;
+                return `export type ${(0, case_1.pascal)(name)}RequestBody = ${type}`;
             }
             else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-                return `${doc}export interface ${(0, case_1.pascal)(name)}RequestBody ${type}`;
+                return `${doc}export type ${(0, case_1.pascal)(name)}RequestBody = ${type}`;
             }
             else {
                 return `${doc}export type ${(0, case_1.pascal)(name)}RequestBody = ${type};`;
@@ -291,10 +291,10 @@ const generateResponsesDefinition = (responses = {}) => {
             const type = (0, exports.getResReqTypes)([['', response]]);
             const isEmptyInterface = type === '{}';
             if (isEmptyInterface) {
-                return `export interface RQ${(0, case_1.pascal)(name)}Response ${type}`;
+                return `export type RQ${(0, case_1.pascal)(name)}Response = ${type}`;
             }
             else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-                return `${doc}export interface RQ${(0, case_1.pascal)(name)}Response ${type}`;
+                return `${doc}export type RQ${(0, case_1.pascal)(name)}Response = ${type}`;
             }
             else {
                 return `${doc}export type RQ${(0, case_1.pascal)(name)}Response = ${type};`;
@@ -422,11 +422,15 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -469,11 +473,15 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -507,12 +515,14 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (): QueryKey => use${componentName}Query.baseKey()
-    use${componentName}Query.updateCache = (
-      _params: undefined,
-      updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+    use${componentName}Query.updateCache = ({updater, options}:
+    {updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(), updater, options);
+    use${componentName}Query.getQueryState = (props?: {filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(), props?.filters);
+    use${componentName}Query.getQueryData = (props?: {filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(), props?.filters);
     use${componentName}Query.prefetch = () =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(), ()=> use${componentName}Query.fetch());
@@ -556,11 +566,15 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -593,11 +607,15 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -642,11 +660,15 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -691,11 +713,15 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -749,11 +775,15 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -801,11 +831,15 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
       queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -849,13 +883,17 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -923,7 +961,7 @@ const importOpenApi = async ({ data, format, apiDirectory, queryClientDir, heade
     QueryKey,
     SetDataOptions,
   } from 'react-query';
-  import { Updater } from 'react-query/types/core/utils';
+  import { Updater, QueryFilters } from 'react-query/types/core/utils';
   import queryString from 'query-string';
   import { AxiosError } from 'axios';

package/lib/esm/import-open-api.js CHANGED Viewed

@@ -130,7 +130,7 @@ export const getObject = (item) => {
         if (item.properties) {
             output += '\n';
         }
-        output += `  [key: string]: ${item.additionalProperties === true ? 'any' : resolveValue(item.additionalProperties)};`;
+        output += `} & { [key: string]: ${item.additionalProperties === true ? 'any' : resolveValue(item.additionalProperties)}`;
     }
     if (item.properties || item.additionalProperties) {
         if (output === '{\n') {
@@ -191,7 +191,7 @@ export const generateInterface = (name, schema) => {
     const scalar = getScalar(schema);
     return `
     ${formatDescription(schema.description)}
-    export interface ${pascal(name)} ${scalar}
+    export type ${pascal(name)} = ${scalar}
   `;
 };
 /**
@@ -247,10 +247,10 @@ export const generateRequestBodiesDefinition = (requestBodies = {}) => {
             const type = getResReqTypes([['', requestBody]]);
             const isEmptyInterface = type === '{}';
             if (isEmptyInterface) {
-                return `export interface ${pascal(name)}RequestBody ${type}`;
+                return `export type ${pascal(name)}RequestBody = ${type}`;
             }
             else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-                return `${doc}export interface ${pascal(name)}RequestBody ${type}`;
+                return `${doc}export type ${pascal(name)}RequestBody = ${type}`;
             }
             else {
                 return `${doc}export type ${pascal(name)}RequestBody = ${type};`;
@@ -273,10 +273,10 @@ export const generateResponsesDefinition = (responses = {}) => {
             const type = getResReqTypes([['', response]]);
             const isEmptyInterface = type === '{}';
             if (isEmptyInterface) {
-                return `export interface RQ${pascal(name)}Response ${type}`;
+                return `export type RQ${pascal(name)}Response = ${type}`;
             }
             else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-                return `${doc}export interface RQ${pascal(name)}Response ${type}`;
+                return `${doc}export type RQ${pascal(name)}Response = ${type}`;
             }
             else {
                 return `${doc}export type RQ${pascal(name)}Response = ${type};`;
@@ -402,11 +402,15 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -449,11 +453,15 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -487,12 +495,14 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (): QueryKey => use${componentName}Query.baseKey()
-    use${componentName}Query.updateCache = (
-      _params: undefined,
-      updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+    use${componentName}Query.updateCache = ({updater, options}:
+    {updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(), updater, options);
+    use${componentName}Query.getQueryState = (props?: {filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(), props?.filters);
+    use${componentName}Query.getQueryData = (props?: {filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(), props?.filters);
     use${componentName}Query.prefetch = () =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(), ()=> use${componentName}Query.fetch());
@@ -536,11 +546,15 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -573,11 +587,15 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -622,11 +640,15 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -671,11 +693,15 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -729,11 +755,15 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -781,11 +811,15 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
       queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -829,13 +863,17 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.updateCache = (
-      params: ${componentName}Variables,
+      {params, updater, options}:
+      {params: ${componentName}Variables,
       updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined
+      options?: SetDataOptions | undefined}
     ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
+    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
     use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
     queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
@@ -902,7 +940,7 @@ export const importOpenApi = async ({ data, format, apiDirectory, queryClientDir
     QueryKey,
     SetDataOptions,
   } from 'react-query';
-  import { Updater } from 'react-query/types/core/utils';
+  import { Updater, QueryFilters } from 'react-query/types/core/utils';
   import queryString from 'query-string';
   import { AxiosError } from 'axios';

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "react-query-lightbase-codegen",
-  "version": "0.1.5",
+  "version": "0.1.8",
   "license": "MIT",
   "main": "./lib/cjs/index.js",
   "module": "./lib/esm/index.js",

package/lib/bin/react-query-codegen-import.js DELETED Viewed

@@ -1,39 +0,0 @@
-import chalk from 'chalk';
-import program from 'commander';
-import { readFileSync, writeFileSync } from 'fs';
-import { join, parse } from 'path';
-import importOpenApi from '../scripts/import-open-api';
-const log = console.log; // tslint:disable-line:no-console
-program.option('-o, --output [value]', 'output file destination');
-program.option('-f, --file [value]', 'input file (yaml or json openapi specs)');
-program.parse(process.argv);
-const createSuccessMessage = (backend) => chalk.green(`${backend ? `[${backend}] ` : ''}🎉  Your OpenAPI spec has been converted into react query hooks`);
-const successWithoutOutputMessage = chalk.yellow('Success! No output path specified; printed to standard output.');
-const importSpecs = async (options) => {
-    if (!options.file) {
-        throw new Error("You need to provide an input specification with `--file`, '--url', or `--github`");
-    }
-    const data = readFileSync(join(process.cwd(), options.file), 'utf-8');
-    const { ext } = parse(options.file);
-    const format = ['.yaml', '.yml'].includes(ext.toLowerCase()) ? 'yaml' : 'json';
-    return importOpenApi({
-        data,
-        format,
-    });
-};
-// Use flags as configuration
-importSpecs(program)
-    .then((data) => {
-    if (program.output) {
-        writeFileSync(join(process.cwd(), program.output), data);
-        log(createSuccessMessage());
-    }
-    else {
-        log(data);
-        log(successWithoutOutputMessage);
-    }
-})
-    .catch((err) => {
-    log(chalk.red(err));
-    process.exit(1);
-});

package/lib/bin/react-query-codegen.js DELETED Viewed

@@ -1,8 +0,0 @@
-import program from 'commander';
-import { readFileSync } from 'fs';
-import { join } from 'path';
-const { version } = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf-8'));
-program
-    .version(version)
-    .command('import [open-api-file]', 'generate react-query hooks from OpenAPI specs')
-    .parse(process.argv);

package/lib/scripts/import-open-api.js DELETED Viewed

@@ -1,605 +0,0 @@
-import { pascal } from 'case';
-import get from 'lodash/get';
-import groupBy from 'lodash/groupBy';
-import isEmpty from 'lodash/isEmpty';
-import set from 'lodash/set';
-import uniq from 'lodash/uniq';
-import swagger2openapi from 'swagger2openapi';
-const yaml = require('js-yaml');
-const IdentifierRegexp = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-/**
- * Import and parse the openapi spec from a yaml/json
- */
-const importSpecs = (data, extension) => {
-    const schema = extension === 'yaml' ? yaml.load(data) : JSON.parse(data);
-    return new Promise((resolve, reject) => {
-        if (!schema.openapi || !schema.openapi.startsWith('3.')) {
-            swagger2openapi.convertObj(schema, {}, (err, convertedObj) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(convertedObj.openapi);
-                }
-            });
-        }
-        else {
-            resolve(schema);
-        }
-    });
-};
-/**
- * Discriminator helper for `ReferenceObject`
- */
-export const isReference = (property) => {
-    return Boolean(property.$ref);
-};
-/**
- * Return the typescript equivalent of open-api data type
- */
-export const getScalar = (item) => {
-    const nullable = item.nullable ? ' | null' : '';
-    switch (item.type) {
-        case 'number':
-        case 'integer':
-            return 'number' + nullable;
-        case 'boolean':
-            return 'boolean' + nullable;
-        case 'array':
-            return getArray(item) + nullable;
-        case 'string':
-            return (item.enum ? `"${item.enum.join(`" | "`)}"` : 'string') + nullable;
-        case 'object':
-        default:
-            return getObject(item) + nullable;
-    }
-};
-/**
- * Return the output type from the $ref
- */
-export const getRef = ($ref) => {
-    if ($ref.startsWith('#/components/schemas')) {
-        return pascal($ref.replace('#/components/schemas/', ''));
-    }
-    else if ($ref.startsWith('#/components/responses')) {
-        return pascal($ref.replace('#/components/responses/', '')) + 'Response';
-    }
-    else if ($ref.startsWith('#/components/parameters')) {
-        return pascal($ref.replace('#/components/parameters/', '')) + 'Parameter';
-    }
-    else if ($ref.startsWith('#/components/requestBodies')) {
-        return pascal($ref.replace('#/components/requestBodies/', '')) + 'RequestBody';
-    }
-    else {
-        throw new Error('This library only resolve $ref that are include into `#/components/*` for now');
-    }
-};
-/**
- * Return the output type from an array
- */
-export const getArray = (item) => {
-    if (item.items) {
-        if (!isReference(item.items) && (item.items.oneOf || item.items.allOf || item.items.enum)) {
-            return `(${resolveValue(item.items)})[]`;
-        }
-        else {
-            return `${resolveValue(item.items)}[]`;
-        }
-    }
-    else {
-        throw new Error('All arrays must have an `items` key define');
-    }
-};
-/**
- * Return the output type from an object
- */
-export const getObject = (item) => {
-    if (isReference(item)) {
-        return getRef(item.$ref);
-    }
-    if (item.allOf) {
-        return item.allOf.map(resolveValue).join(' & ');
-    }
-    if (item.oneOf) {
-        return item.oneOf.map(resolveValue).join(' | ');
-    }
-    if (!item.type && !item.properties && !item.additionalProperties) {
-        return '{}';
-    }
-    // Free form object (https://swagger.io/docs/specification/data-models/data-types/#free-form)
-    if (item.type === 'object' &&
-        !item.properties &&
-        (!item.additionalProperties || item.additionalProperties === true || isEmpty(item.additionalProperties))) {
-        return '{[key: string]: any}';
-    }
-    // Consolidation of item.properties & item.additionalProperties
-    let output = '{\n';
-    if (item.properties) {
-        output += Object.entries(item.properties)
-            .map(([key, prop]) => {
-            const doc = isReference(prop) ? '' : formatDescription(prop.description, 2);
-            const isRequired = (item.required || []).includes(key);
-            const processedKey = IdentifierRegexp.test(key) ? key : `"${key}"`;
-            return `  ${doc}${processedKey}${isRequired ? '' : '?'}: ${resolveValue(prop)};`;
-        })
-            .join('\n');
-    }
-    if (item.additionalProperties) {
-        if (item.properties) {
-            output += '\n';
-        }
-        output += `  [key: string]: ${item.additionalProperties === true ? 'any' : resolveValue(item.additionalProperties)};`;
-    }
-    if (item.properties || item.additionalProperties) {
-        if (output === '{\n') {
-            return '{}';
-        }
-        return output + '\n}';
-    }
-    return item.type === 'object' ? '{[key: string]: any}' : 'any';
-};
-/**
- * Resolve the value of a schema object to a proper type definition.
- */
-export const resolveValue = (schema) => isReference(schema) ? getRef(schema.$ref) : getScalar(schema);
-/**
- * Extract responses / request types from open-api specs
- */
-export const getResReqTypes = (responsesOrRequests) => uniq(responsesOrRequests.map(([_, res]) => {
-    if (!res) {
-        return 'void';
-    }
-    if (isReference(res)) {
-        return getRef(res.$ref);
-    }
-    if (res.content) {
-        for (let contentType of Object.keys(res.content)) {
-            if (contentType.startsWith('application/json') ||
-                contentType.startsWith('application/octet-stream')) {
-                const schema = res.content[contentType].schema;
-                return resolveValue(schema);
-            }
-        }
-        return 'void';
-    }
-    return 'void';
-})).join(' | ');
-/**
- * Return every params in a path
- *
- * @example
- * ```
- * getParamsInPath("/pet/{category}/{name}/");
- * // => ["category", "name"]
- * ```
- */
-export const getParamsInPath = (path) => {
-    let n;
-    const output = [];
-    const templatePathRegex = /\{(\w+)}/g;
-    while ((n = templatePathRegex.exec(path)) !== null) {
-        output.push(n[1]);
-    }
-    return output;
-};
-/**
- * Generate the interface string
- */
-export const generateInterface = (name, schema) => {
-    const scalar = getScalar(schema);
-    return `${formatDescription(schema.description)}export interface ${pascal(name)} ${scalar}`;
-};
-/**
- * Propagate every `discriminator.propertyName` mapping to the original ref
- *
- * Note: This method directly mutate the `specs` object.
- */
-export const resolveDiscriminator = (specs) => {
-    if (specs.components && specs.components.schemas) {
-        Object.values(specs.components.schemas).forEach((schema) => {
-            if (isReference(schema) || !schema.discriminator || !schema.discriminator.mapping) {
-                return;
-            }
-            const { mapping, propertyName } = schema.discriminator;
-            Object.entries(mapping).forEach(([name, ref]) => {
-                if (!ref.startsWith('#/components/schemas/')) {
-                    throw new Error('Discriminator mapping outside of `#/components/schemas` is not supported');
-                }
-                set(specs, `components.schemas.${ref.slice('#/components/schemas/'.length)}.properties.${propertyName}.enum`, [name]);
-            });
-        });
-    }
-};
-/**
- * Extract all types from #/components/schemas
- */
-export const generateSchemasDefinition = (schemas = {}) => {
-    if (isEmpty(schemas)) {
-        return '';
-    }
-    return (Object.entries(schemas)
-        .map(([name, schema]) => !isReference(schema) &&
-        (!schema.type || schema.type === 'object') &&
-        !schema.allOf &&
-        !schema.oneOf &&
-        !isReference(schema) &&
-        !schema.nullable
-        ? generateInterface(name, schema)
-        : `${formatDescription(isReference(schema) ? undefined : schema.description)}export type ${pascal(name)} = ${resolveValue(schema)};`)
-        .join('\n\n') + '\n');
-};
-/**
- * Extract all types from #/components/requestBodies
- */
-export const generateRequestBodiesDefinition = (requestBodies = {}) => {
-    if (isEmpty(requestBodies)) {
-        return '';
-    }
-    return ('\n' +
-        Object.entries(requestBodies)
-            .map(([name, requestBody]) => {
-            const doc = isReference(requestBody) ? '' : formatDescription(requestBody.description);
-            const type = getResReqTypes([['', requestBody]]);
-            const isEmptyInterface = type === '{}';
-            if (isEmptyInterface) {
-                return `export interface ${pascal(name)}RequestBody ${type}`;
-            }
-            else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-                return `${doc}export interface ${pascal(name)}RequestBody ${type}`;
-            }
-            else {
-                return `${doc}export type ${pascal(name)}RequestBody = ${type};`;
-            }
-        })
-            .join('\n\n') +
-        '\n');
-};
-/**
- * Extract all types from #/components/responses
- */
-export const generateResponsesDefinition = (responses = {}) => {
-    if (isEmpty(responses)) {
-        return '';
-    }
-    return ('\n' +
-        Object.entries(responses)
-            .map(([name, response]) => {
-            const doc = isReference(response) ? '' : formatDescription(response.description);
-            const type = getResReqTypes([['', response]]);
-            const isEmptyInterface = type === '{}';
-            if (isEmptyInterface) {
-                return `export interface RQ${pascal(name)}Response ${type}`;
-            }
-            else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-                return `${doc}export interface RQ${pascal(name)}Response ${type}`;
-            }
-            else {
-                return `${doc}export type RQ${pascal(name)}Response = ${type};`;
-            }
-        })
-            .join('\n\n') +
-        '\n');
-};
-/**
- * Format a description to code documentation.
- */
-export const formatDescription = (description, tabSize = 0) => description
-    ? `/**\n${description
-        .split('\n')
-        .map((i) => `${' '.repeat(tabSize)} * ${i}`)
-        .join('\n')}\n${' '.repeat(tabSize)} */\n${' '.repeat(tabSize)}`
-    : '';
-/**
- * Generate a react-query component from openapi operation specs
- */
-export const generateRestfulComponent = (operation, verb, route, operationIds, parameters = [], schemasComponents) => {
-    if (!operation.operationId) {
-        throw new Error(`Every path must have a operationId - No operationId set for ${verb} ${route}`);
-    }
-    if (operationIds.includes(operation.operationId)) {
-        throw new Error(`"${operation.operationId}" is duplicated in your schema definition!`);
-    }
-    operationIds.push(operation.operationId);
-    route = route.replace(/\{/g, '${'); // `/pet/{id}` => `/pet/${id}`
-    // Remove the last param of the route if we are in the DELETE case
-    let lastParamInTheRoute = null;
-    const componentName = pascal(operation.operationId);
-    const isOk = ([statusCode]) => statusCode.toString().startsWith('2');
-    const responseTypes = getResReqTypes(Object.entries(operation.responses).filter(isOk)) || 'void';
-    const requestBodyTypes = getResReqTypes([['body', operation.requestBody]]);
-    const needAResponseComponent = true;
-    const paramsInPath = getParamsInPath(route).filter((param) => !(verb === 'delete' && param === lastParamInTheRoute));
-    const { query: queryParams = [], path: pathParams = [] } = groupBy([...parameters, ...(operation.parameters || [])].map((p) => {
-        if (isReference(p)) {
-            return get(schemasComponents, p.$ref.replace('#/components/', '').replace('/', '.'));
-        }
-        else {
-            return p;
-        }
-    }), 'in');
-    const paramsTypes = paramsInPath
-        .map((p) => {
-        try {
-            const { name, required, schema } = pathParams.find((i) => i.name === p);
-            return `${name}${required ? '' : '?'}: ${resolveValue(schema)}`;
-        }
-        catch (err) {
-            throw new Error(`The path params ${p} can't be found in parameters (${operation.operationId})`);
-        }
-    })
-        .join('; ');
-    const queryParamsType = queryParams
-        .map((p) => {
-        const processedName = IdentifierRegexp.test(p.name) ? p.name : `"${p.name}"`;
-        return `${formatDescription(p.description, 2)}${processedName}${p.required ? '' : '?'}: ${resolveValue(p.schema)}`;
-    })
-        .join(';\n  ');
-    // Retrieve the type of the param for delete verb
-    const lastParamInTheRouteDefinition = operation.parameters && lastParamInTheRoute
-        ? operation.parameters.find((p) => {
-            if (isReference(p)) {
-                return false;
-            }
-            return p.name === lastParamInTheRoute;
-        }) // Reference is not possible
-        : { schema: { type: 'string' } };
-    if (!lastParamInTheRouteDefinition) {
-        throw new Error(`The path params ${lastParamInTheRoute} can't be found in parameters (${operation.operationId})`);
-    }
-    let genericsTypes = `${needAResponseComponent ? componentName + 'Res' : responseTypes}`;
-    if (verb !== 'get') {
-        genericsTypes = `${needAResponseComponent ? componentName + 'Res' : responseTypes}`;
-    }
-    const description = formatDescription(operation.summary && operation.description
-        ? `${operation.summary}\n\n${operation.description}`
-        : `${operation.summary || ''}${operation.description || ''}`);
-    let output = `\n\n${description}`;
-    const typeOrInterface = `type ${componentName}Res =`;
-    output += `
-  ${needAResponseComponent ? `export ${typeOrInterface} ${responseTypes}` : ''}
-  `;
-    const queryParam = queryParamsType && queryParamsType !== 'void' ? `${queryParamsType}` : '';
-    const requestBodyComponent = requestBodyTypes && requestBodyTypes !== 'void' ? `${requestBodyTypes}` : '';
-    // QUERIES
-    if (!requestBodyComponent && paramsInPath.length && !queryParam) {
-        output += `
-    type ${componentName}Params = {${paramsTypes}};
-    use${componentName}Query.fetch = async (props: ${componentName}Params ) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route.replace(/\{/g, '{props.')}\`);
-      return result.data;
-    }
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-    use${componentName}Query.queryKey = (params: ${componentName}Params ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
-    } & ${componentName}Params
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
-      return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
-      { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
-    );}
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Params, T>
-    }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
-    return useMutation(async ({${paramsInPath.join(', ')}}) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`)
-      return result.data
-    },
-    props?.options
-  )};`;
-    }
-    if (!requestBodyComponent && paramsInPath.length && queryParam) {
-        output += `
-    type ${componentName}Params = {
-      ${paramsTypes}
-      ${queryParamsType}
-    }
-    use${componentName}Query.fetch = async (props: ${componentName}Params) => {
-      const {${paramsInPath.join(', ')}, ...queryParams} = props
-      const params = queryString.stringify(queryParams);
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
-      return result.data;
-    }
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-    use${componentName}Query.queryKey = (params: ${componentName}Params): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
-    } & ${componentName}Params
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
-      return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
-    );}
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Params, T>
-    }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
-    return useMutation(async (data) => {
-      const {${paramsInPath.join(', ')}, ...queryParams} = data
-      const params = queryString.stringify(queryParams);
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
-      return result.data
-    },
-    props?.options
-  )};`;
-    }
-    if (!requestBodyComponent && !paramsInPath.length && !queryParam) {
-        output += `
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-    use${componentName}Query.queryKey = (): QueryKey => use${componentName}Query.baseKey()
-    use${componentName}Query.fetch = async () => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`);
-      return result.data;
-    }
-    type ${componentName}QueryProps<T = ${genericsTypes}> = {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
-    }
-    export function use${componentName}Query<T = ${genericsTypes}>(props?: ${componentName}QueryProps<T>) {
-      return useQuery(use${componentName}Query.queryKey(), use${componentName}Query.fetch, props?.options
-    );}
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, void, T>
-    }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
-      return useMutation(async () => {
-        const result = await api.${verb}<${genericsTypes}>(\`${route}\`);
-        return result.data;
-      },
-      props?.options
-    )};
-    `;
-    }
-    if (!requestBodyComponent && !paramsInPath.length && queryParam) {
-        output += `
-    type ${componentName}Params = {
-      ${queryParamsType}
-    }
-    use${componentName}Query.fetch = async (props: ${componentName}Params) => {
-      const params = queryString.stringify({${queryParams
-            .map((param) => `${param.name}: props.${param.name}`)
-            .join(',')}});
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
-      return result.data;
-    }
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-    use${componentName}Query.queryKey = (params: ${componentName}Params ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
-    } & ${componentName}Params
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
-      return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
-      {
-        enabled: !!props.${queryParams.map((param) => param.name).join(' && !!props.')},
-        ...options
-      }
-    );}
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Params, T>
-    }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
-      return useMutation(async (data) => {
-        const params = queryString.stringify({${queryParams
-            .map((param) => `${param.name}: data.${param.name}`)
-            .join(',')}});
-        const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
-        return result.data;
-      },
-      props?.options
-  )};`;
-    }
-    if (requestBodyComponent && !paramsInPath.length && !queryParam) {
-        output += `
-    use${componentName}Query.fetch = async (body:${requestBodyComponent}) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
-        return result.data
-      }
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-    use${componentName}Query.queryKey = (params:${requestBodyComponent}): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
-    } & ${requestBodyComponent}
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
-      return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body), options
-    );}
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${requestBodyComponent}, T>
-    }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
-    return useMutation(async (body) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
-      return result.data
-    },
-    props?.options
-  )};`;
-    }
-    if (requestBodyComponent && paramsInPath.length && !queryParam) {
-        output += `
-    // HDHD
-    type ${componentName}Params = {${paramsTypes}} & ${requestBodyComponent}
-    use${componentName}Query.fetch = async (props: ${componentName}Params) => {
-      const {${paramsInPath.join(', ')}, ...body} = props
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
-      return result.data
-    }
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-    use${componentName}Query.queryKey = (params: ${componentName}Params ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
-    } & ${componentName}Params
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
-    return useQuery(use${componentName}Query.queryKey(props), async () =>  use${componentName}Query.fetch(props), { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
-    );}
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError,${componentName}Params, T>
-    }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
-      return useMutation(async (body) => use${componentName}Query.fetch(body),
-      props?.options
-  )};`;
-    }
-    if (requestBodyComponent && queryParam) {
-        output += `// TODO: CODEGEN DOES NOT SUPPORT QUERYPARAM AND REQUESTBODY`;
-    }
-    return output;
-};
-/**
- * Main entry of the generator. Generate react-query component from openAPI.
- */
-const importOpenApi = async ({ data, format }) => {
-    const operationIds = [];
-    let specs = await importSpecs(data, format);
-    resolveDiscriminator(specs);
-    let output = `
-  import { useQuery, useMutation, UseQueryOptions, UseMutationOptions, QueryKey } from 'react-query';
-  import queryString from 'query-string';
-  import {AxiosError} from 'axios';
-  import { api } from 'api';
-  `;
-    output += '\n\n// SCEHMAS\n';
-    output += generateSchemasDefinition(specs.components && specs.components.schemas);
-    output += '\n\n// RESPONSES\n';
-    output += generateResponsesDefinition(specs.components && specs.components.responses);
-    output += '\n\n// REQUEST BODIES\n';
-    output += generateRequestBodiesDefinition(specs.components && specs.components.requestBodies);
-    output += '\n\n// HOOKS\n';
-    Object.entries(specs.paths).forEach(([route, verbs]) => {
-        Object.entries(verbs).forEach(([verb, operation]) => {
-            if (['get', 'post', 'patch', 'put', 'delete'].includes(verb) && !operation.deprecated) {
-                output += generateRestfulComponent(operation, verb, route, operationIds, verbs.parameters, specs.components);
-            }
-        });
-    });
-    return output;
-};
-export default importOpenApi;

package/lib/types.js DELETED Viewed

	@@ -1 +0,0 @@
1	- export {};