@acrool/rtk-query-codegen-openapi 1.4.0-alpha.1 → 1.4.0-alpha.2

package/lib/index.js

@@ -489,12 +489,61 @@ export interface IRequestConfig {
   timeout?: number;
 }
 
-export type IRestFulEndpointsQueryReturn<TVariables> = TVariables extends void ? 
-  void | {fetchOptions?: IRequestConfig;}: 
+export type IRestFulEndpointsQueryReturn<TVariables> = TVariables extends void ?
+  void | {fetchOptions?: IRequestConfig;}:
   {
       variables: TVariables;
       fetchOptions?: IRequestConfig;
   };
+
+export type UseSimpleQuery<TRes, TArg = void> = (
+  arg: TArg,
+  options?: {
+    skip?: boolean;
+    pollingInterval?: number;
+    refetchOnMountOrArgChange?: boolean | number;
+    refetchOnFocus?: boolean;
+    refetchOnReconnect?: boolean;
+  }
+) => {
+  data: TRes | undefined;
+  currentData: TRes | undefined;
+  isLoading: boolean;
+  isFetching: boolean;
+  isSuccess: boolean;
+  isError: boolean;
+  isUninitialized: boolean;
+  error: unknown;
+  refetch: () => void;
+};
+
+export type UseSimpleMutation<TRes, TArg = void> = () => [
+  (arg: TArg) => {unwrap: () => Promise<TRes>} & PromiseLike<{data: TRes} | {error: unknown}>,
+  {
+    data: TRes | undefined;
+    isLoading: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    isUninitialized: boolean;
+    error: unknown;
+    reset: () => void;
+  }
+];
+
+export type UseSimpleLazyQuery<TRes, TArg = void> = () => [
+  (arg: TArg, preferCacheValue?: boolean) => void,
+  {
+    data: TRes | undefined;
+    currentData: TRes | undefined;
+    isLoading: boolean;
+    isFetching: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    isUninitialized: boolean;
+    error: unknown;
+  },
+  {lastArg: TArg | undefined}
+];
 `;
 }
 
@@ -1107,10 +1156,36 @@ ${paramsLines}
   const hasTags = endpointInfos.some((info) => info.tags && info.tags.length > 0);
   const tagTypesImport = hasTags ? `import {ECacheTagTypes} from "../tagTypes";
 ` : "";
+  const hasQuery = endpointInfos.some((info) => info.isQuery);
+  const hasLazyQuery = hasQuery && !!options.useLazyQueries;
+  const hasMutation = endpointInfos.some((info) => !info.isQuery);
+  const simpleTypeImports = [];
+  if (hasQuery) simpleTypeImports.push("UseSimpleQuery");
+  if (hasMutation) simpleTypeImports.push("UseSimpleMutation");
+  if (hasLazyQuery) simpleTypeImports.push("UseSimpleLazyQuery");
+  const simpleTypeImportStatement = simpleTypeImports.length > 0 ? `import type { ${simpleTypeImports.join(", ")} } from "../common-types";
+` : "";
+  const hookExports = endpointInfos.map((info) => {
+    const capitalizedOperationName = info.operationName.charAt(0).toUpperCase() + info.operationName.slice(1);
+    const argType = info.isVoidArg ? "void" : `${httpClientTypeName}<${info.argTypeName}>`;
+    const lines = [];
+    if (info.isQuery) {
+      const regularHook = `use${capitalizedOperationName}Query`;
+      lines.push(`export const ${regularHook} = injectedRtkApi.${regularHook} as UseSimpleQuery<${info.responseTypeName}, ${argType}>;`);
+      if (options.useLazyQueries) {
+        const lazyHook = `useLazy${capitalizedOperationName}Query`;
+        lines.push(`export const ${lazyHook} = injectedRtkApi.${lazyHook} as UseSimpleLazyQuery<${info.responseTypeName}, ${argType}>;`);
+      }
+    } else {
+      const mutationHook = `use${capitalizedOperationName}Mutation`;
+      lines.push(`export const ${mutationHook} = injectedRtkApi.${mutationHook} as UseSimpleMutation<${info.responseTypeName}, ${argType}>;`);
+    }
+    return lines.join("\n");
+  }).join("\n");
   return `/* eslint-disable */
 // [Warning] Generated automatically - do not edit manually
 
-${apiImport}${httpClientImport}${tagTypesImport}
+${apiImport}${httpClientImport}${tagTypesImport}${simpleTypeImportStatement}
 ${typeImportStatement}
 
 
@@ -1120,24 +1195,7 @@ ${endpoints}
     }),
 });
 
-export const {
-${endpointInfos.map((info) => {
-    const capitalizedOperationName = info.operationName.charAt(0).toUpperCase() + info.operationName.slice(1);
-    if (info.isQuery) {
-      const regularHook = `use${capitalizedOperationName}Query`;
-      if (options.useLazyQueries) {
-        const lazyHook = `useLazy${capitalizedOperationName}Query`;
-        return `  ${regularHook},
-  ${lazyHook},`;
-      } else {
-        return `  ${regularHook},`;
-      }
-    } else {
-      const mutationHook = `use${capitalizedOperationName}Mutation`;
-      return `  ${mutationHook},`;
-    }
-  }).join("\n")}
-} = injectedRtkApi;
+${hookExports}
 
 export default injectedRtkApi;
 `;