@openapi-qraft/tanstack-query-react-plugin 2.0.0-next.7 → 2.0.0-next.8

package/src/ts-factory/getServiceFactory.ts

@@ -1,32 +1,52 @@
 import { ServiceOperation } from '@openapi-qraft/plugin/lib/open-api/getServices';
+import camelCase from 'camelcase';
 import ts from 'typescript';
-
-const SERVICE_OPERATION_QUERY = 'ServiceOperationQuery';
-const SERVICE_OPERATION_MUTATION = 'ServiceOperationMutation';
+import { createServiceOperationCancelQueriesNodes } from './service-operation.generated/ServiceOperationCancelQueries.js';
+import { createServiceOperationFetchInfiniteQueryNodes } from './service-operation.generated/ServiceOperationFetchInfiniteQuery.js';
+import { createServiceOperationFetchQueryNodes } from './service-operation.generated/ServiceOperationFetchQuery.js';
+import { createServiceOperationGetInfiniteQueryDataNodes } from './service-operation.generated/ServiceOperationGetInfiniteQueryData.js';
+import { createServiceOperationGetQueriesDataNodes } from './service-operation.generated/ServiceOperationGetQueriesData.js';
+import { createServiceOperationGetQueryDataNodes } from './service-operation.generated/ServiceOperationGetQueryData.js';
+import { createServiceOperationGetQueryStateNodes } from './service-operation.generated/ServiceOperationGetQueryState.js';
+import { createServiceOperationInvalidateQueriesNodes } from './service-operation.generated/ServiceOperationInvalidateQueries.js';
+import { createServiceOperationIsFetchingQueriesNodes } from './service-operation.generated/ServiceOperationIsFetchingQueries.js';
+import { createServiceOperationIsMutatingQueriesNodes } from './service-operation.generated/ServiceOperationIsMutatingQueries.js';
+import { createServiceOperationMutationFnNodes } from './service-operation.generated/ServiceOperationMutationFn.js';
+import { createServiceOperationQueryFnNodes } from './service-operation.generated/ServiceOperationQueryFn.js';
+import { createServiceOperationRefetchQueriesNodes } from './service-operation.generated/ServiceOperationRefetchQueries.js';
+import { createServiceOperationRemoveQueriesNodes } from './service-operation.generated/ServiceOperationRemoveQueries.js';
+import { createServiceOperationResetQueriesNodes } from './service-operation.generated/ServiceOperationResetQueries.js';
+import { createServiceOperationSetInfiniteQueryDataNodes } from './service-operation.generated/ServiceOperationSetInfiniteQueryData.js';
+import { createServiceOperationSetQueriesDataNodes } from './service-operation.generated/ServiceOperationSetQueriesData.js';
+import { createServiceOperationSetQueryDataNodes } from './service-operation.generated/ServiceOperationSetQueryData.js';
+import { createServiceOperationUseInfiniteQueryNodes } from './service-operation.generated/ServiceOperationUseInfiniteQuery.js';
+import { createServiceOperationUseIsFetchingQueriesNodes } from './service-operation.generated/ServiceOperationUseIsFetchingQueries.js';
+import { createServiceOperationUseIsMutatingNodes } from './service-operation.generated/ServiceOperationUseIsMutating.js';
+import { createServiceOperationUseMutationNodes } from './service-operation.generated/ServiceOperationUseMutation.js';
+import { createServiceOperationUseMutationStateNodes } from './service-operation.generated/ServiceOperationUseMutationState.js';
+import { createServiceOperationUseQueriesNodes } from './service-operation.generated/ServiceOperationUseQueries.js';
+import { createServiceOperationUseQueryNodes } from './service-operation.generated/ServiceOperationUseQuery.js';
+import { createServiceOperationUseSuspenseInfiniteQueryNodes } from './service-operation.generated/ServiceOperationUseSuspenseInfiniteQuery.js';
+import { createServiceOperationUseSuspenseQueriesNodes } from './service-operation.generated/ServiceOperationUseSuspenseQueries.js';
+import { createServiceOperationUseSuspenseQueryNodes } from './service-operation.generated/ServiceOperationUseSuspenseQuery.js';
 
 const factory = ts.factory;
 
 export type ServiceImportsFactoryOptions = {
   openapiTypesImportPath: string;
-  operationGenericsImportPath: string;
 };
 
 export const getServiceFactory = (
   service: { typeName: string; variableName: string },
   operations: ServiceOperation[],
-  {
-    openapiTypesImportPath,
-    operationGenericsImportPath,
-  }: ServiceImportsFactoryOptions
+  { openapiTypesImportPath }: ServiceImportsFactoryOptions
 ) => {
   return [
     getOpenAPISchemaImportsFactory(openapiTypesImportPath),
-    getServiceOperationGenericsPathImportsFactory(
-      operationGenericsImportPath,
-      operations
-    ),
+    ...getServiceOperationImportsFactory(operations),
     getServiceInterfaceFactory(service, operations),
     getServiceVariableFactory(service, operations),
+    ...getOperationsTypes(operations),
   ];
 };
 
@@ -50,7 +70,42 @@ const getOpenAPISchemaImportsFactory = (schemaTypesPath: string) => {
   );
 };
 
-const getServiceOperationGenericsPathImportsFactory = (
+const getServiceOperationImportsFactory = (operations: ServiceOperation[]) => {
+  const factory = ts.factory;
+
+  const moduleImports = getModuleTypeImports([
+    ...(operations.some((operation) => operation.method === 'get')
+      ? createServicesQueryOperationNodes()
+      : []),
+    ...(operations.some((operation) => operation.method !== 'get')
+      ? createServicesMutationOperationNodes()
+      : []),
+  ]);
+
+  return Object.entries(moduleImports).map(
+    ([moduleName, importSpecifierNames]) => {
+      return factory.createImportDeclaration(
+        undefined,
+        factory.createImportClause(
+          true,
+          undefined,
+          factory.createNamedImports(
+            importSpecifierNames.map((specifier) =>
+              factory.createImportSpecifier(
+                false,
+                undefined,
+                factory.createIdentifier(specifier)
+              )
+            )
+          )
+        ),
+        factory.createStringLiteral(moduleName)
+      );
+    }
+  );
+};
+
+const __getServiceOperationGenericsPathImportsFactory = (
   operationGenericsPath: string,
   operations: ServiceOperation[]
 ) => {
@@ -105,28 +160,78 @@ const getServiceInterfaceFactory = (
 };
 
 const getServiceInterfaceOperationFactory = (operation: ServiceOperation) => {
+  const operationMethodNodes = getMethodSignatureNodes(
+    operation.method === 'get'
+      ? createServicesQueryOperationNodes()
+      : createServicesMutationOperationNodes()
+  );
+  operationMethodNodes.forEach(
+    (node) => void addSyntheticLeadingOperationComment(node, operation)
+  );
+
   const node = factory.createPropertySignature(
     undefined,
     factory.createIdentifier(operation.name),
     undefined,
-    factory.createTypeReferenceNode(
-      factory.createIdentifier(
-        operation.method === 'get'
-          ? SERVICE_OPERATION_QUERY
-          : SERVICE_OPERATION_MUTATION
+    factory.createTypeLiteralNode([
+      ...replaceGenericTypesWithOperationTypes(operationMethodNodes, operation),
+      factory.createPropertySignature(
+        undefined,
+        factory.createIdentifier('schema'),
+        undefined,
+        factory.createTypeReferenceNode(
+          getOperationSchemaTypeName(operation),
+          undefined
+        )
       ),
-      [
-        getOperationSchemaFactory(operation),
-
-        operation.method !== 'get' ? getOperationBodyFactory(operation) : null,
-
-        getOperationResponseFactory(operation, 'success'),
-
-        getOperationParametersFactory(operation),
-
-        getOperationResponseFactory(operation, 'errors'),
-      ].filter((node): node is NonNullable<typeof node> => Boolean(node))
-    )
+      factory.createPropertySignature(
+        undefined,
+        factory.createIdentifier('types'),
+        undefined,
+        factory.createTypeLiteralNode(
+          [
+            factory.createPropertySignature(
+              undefined,
+              factory.createIdentifier('parameters'),
+              undefined,
+              factory.createTypeReferenceNode(
+                getOperationParametersTypeName(operation),
+                undefined
+              )
+            ),
+            factory.createPropertySignature(
+              undefined,
+              factory.createIdentifier('data'),
+              undefined,
+              factory.createTypeReferenceNode(
+                getOperationDataTypeName(operation),
+                undefined
+              )
+            ),
+            factory.createPropertySignature(
+              undefined,
+              factory.createIdentifier('error'),
+              undefined,
+              factory.createTypeReferenceNode(
+                getOperationErrorTypeName(operation),
+                undefined
+              )
+            ),
+            operation.method !== 'get'
+              ? factory.createPropertySignature(
+                  undefined,
+                  factory.createIdentifier('body'),
+                  undefined,
+                  factory.createTypeReferenceNode(
+                    getOperationBodyTypeName(operation),
+                    undefined
+                  )
+                )
+              : undefined,
+          ].filter((node) => !!node)
+        )
+      ),
+    ])
   );
 
   addSyntheticLeadingOperationComment(node, operation);
@@ -320,6 +425,65 @@ const getServiceVariableFactory = (
   );
 };
 
+const getOperationsTypes = (operations: ServiceOperation[]) => {
+  return operations.flatMap((operation) => {
+    const nodes = [
+      factory.createTypeAliasDeclaration(
+        undefined,
+        factory.createIdentifier(getOperationSchemaTypeName(operation)),
+        undefined,
+        getOperationSchemaFactory(operation)
+      ),
+      factory.createTypeAliasDeclaration(
+        undefined,
+        factory.createIdentifier(getOperationParametersTypeName(operation)),
+        undefined,
+        getOperationParametersFactory(operation)
+      ),
+      factory.createTypeAliasDeclaration(
+        undefined,
+        factory.createIdentifier(getOperationDataTypeName(operation)),
+        undefined,
+        getOperationResponseFactory(operation, 'success')
+      ),
+      factory.createTypeAliasDeclaration(
+        undefined,
+        factory.createIdentifier(getOperationErrorTypeName(operation)),
+        undefined,
+        getOperationResponseFactory(operation, 'errors')
+      ),
+    ];
+
+    if (operation.method !== 'get') {
+      nodes.push(
+        factory.createTypeAliasDeclaration(
+          undefined,
+          factory.createIdentifier(getOperationBodyTypeName(operation)),
+          undefined,
+          getOperationBodyFactory(operation)
+        )
+      );
+    }
+
+    return nodes;
+  });
+};
+
+const getOperationSchemaTypeName = (operation: ServiceOperation) =>
+  camelCase(`${operation.name}-Schema`, { pascalCase: true });
+
+const getOperationParametersTypeName = (operation: ServiceOperation) =>
+  camelCase(`${operation.name}-Parameters`, { pascalCase: true });
+
+const getOperationDataTypeName = (operation: ServiceOperation) =>
+  camelCase(`${operation.name}-Data`, { pascalCase: true });
+
+const getOperationErrorTypeName = (operation: ServiceOperation) =>
+  camelCase(`${operation.name}-Error`, { pascalCase: true });
+
+const getOperationBodyTypeName = (operation: ServiceOperation) =>
+  camelCase(`${operation.name}-Body`, { pascalCase: true });
+
 const getServiceVariableTypeFactory = (operation: ServiceOperation) => {
   const node = factory.createPropertySignature(
     undefined,
@@ -435,3 +599,128 @@ const getOperationSecuritySchemas = (
   security.flatMap((security) =>
     Object.keys(security).map((securitySchemaName) => securitySchemaName)
   );
+
+const createServicesQueryOperationNodes = () => [
+  ...createServiceOperationCancelQueriesNodes(),
+  ...createServiceOperationUseQueryNodes(),
+  ...createServiceOperationFetchInfiniteQueryNodes(),
+  ...createServiceOperationFetchQueryNodes(),
+  ...createServiceOperationGetInfiniteQueryDataNodes(),
+  ...createServiceOperationGetQueriesDataNodes(),
+  ...createServiceOperationGetQueryDataNodes(),
+  ...createServiceOperationGetQueryStateNodes(),
+  ...createServiceOperationInvalidateQueriesNodes(),
+  ...createServiceOperationIsFetchingQueriesNodes(),
+  ...createServiceOperationQueryFnNodes(),
+  ...createServiceOperationRefetchQueriesNodes(),
+  ...createServiceOperationRemoveQueriesNodes(),
+  ...createServiceOperationResetQueriesNodes(),
+  ...createServiceOperationSetInfiniteQueryDataNodes(),
+  ...createServiceOperationSetQueriesDataNodes(),
+  ...createServiceOperationSetQueryDataNodes(),
+  ...createServiceOperationUseInfiniteQueryNodes(),
+  ...createServiceOperationUseIsFetchingQueriesNodes(),
+  ...createServiceOperationUseQueriesNodes(),
+  ...createServiceOperationUseQueryNodes(),
+  ...createServiceOperationUseSuspenseInfiniteQueryNodes(),
+  ...createServiceOperationUseSuspenseQueriesNodes(),
+  ...createServiceOperationUseSuspenseQueryNodes(),
+];
+
+const createServicesMutationOperationNodes = () => [
+  ...createServiceOperationUseMutationNodes(),
+  ...createServiceOperationUseIsMutatingNodes(),
+  ...createServiceOperationIsMutatingQueriesNodes(),
+  ...createServiceOperationMutationFnNodes(),
+  ...createServiceOperationUseMutationStateNodes(),
+];
+
+const getMethodSignatureNodes = (
+  nodes: ts.Node[]
+): (ts.MethodSignature | ts.CallSignatureDeclaration)[] => {
+  return nodes.flatMap((node) =>
+    ts.isInterfaceDeclaration(node)
+      ? node.members.filter(
+          (node) =>
+            ts.isMethodSignature(node) || ts.isCallSignatureDeclaration(node)
+        )
+      : []
+  );
+};
+
+const getModuleTypeImports = (nodes: ts.Node[]) => {
+  return nodes
+    .map((node) => {
+      const foo =
+        ts.isImportDeclaration(node) &&
+        ts.isStringLiteral(node.moduleSpecifier) &&
+        node.importClause?.isTypeOnly &&
+        node.importClause.namedBindings &&
+        ts.isNamedImports(node.importClause.namedBindings)
+          ? {
+              module: node.moduleSpecifier.text,
+              imports: node.importClause.namedBindings.elements
+                .filter(ts.isImportSpecifier)
+                .map((specifier) => specifier.name.text),
+            }
+          : undefined;
+
+      return foo;
+    })
+    .reduce<Record<string, string[]>>((acc, item) => {
+      if (!item) return acc;
+      if (!acc[item.module])
+        acc[item.module] = item.imports.filter(arrayFilterUniqueCallback);
+      else
+        acc[item.module] = [...acc[item.module], ...item.imports].filter(
+          arrayFilterUniqueCallback
+        );
+
+      return acc;
+    }, {});
+};
+
+function replaceGenericTypesWithOperationTypes<T extends ts.Node>(
+  node: T[],
+  operation: ServiceOperation
+): T[] {
+  const transformer =
+    (context: ts.TransformationContext) => (rootNode: ts.Node) => {
+      function visit(node: ts.Node): ts.Node {
+        if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName)) {
+          let newTypeName;
+
+          if (node.typeName.text === 'TSchema')
+            newTypeName = getOperationSchemaTypeName(operation);
+          else if (node.typeName.text === 'TParams')
+            newTypeName = getOperationParametersTypeName(operation);
+          else if (
+            node.typeName.text === 'TQueryFnData' ||
+            node.typeName.text === 'TMutationData'
+          )
+            newTypeName = getOperationDataTypeName(operation);
+          else if (node.typeName.text === 'TError')
+            newTypeName = getOperationErrorTypeName(operation);
+          else if (node.typeName.text === 'TBody')
+            newTypeName = getOperationBodyTypeName(operation);
+
+          if (newTypeName) {
+            return ts.factory.createTypeReferenceNode(
+              ts.factory.createIdentifier(newTypeName),
+              node.typeArguments
+            );
+          }
+        }
+        return ts.visitEachChild(node, visit, context);
+      }
+      return ts.visitNode(rootNode, visit);
+    };
+
+  const result = ts.transform(node, [transformer]);
+
+  return result.transformed as T[];
+}
+
+function arrayFilterUniqueCallback<T>(value: T, index: number, self: T[]) {
+  return self.indexOf(value) === index;
+}

package/src/ts-factory/service-operation.generated/ServiceOperationCancelQueries.ts

@@ -0,0 +1,171 @@
+/** This file was auto-generated by "@openapi-qraft/tanstack-query-react-plugin" codegen script. */
+import ts from "typescript";
+const factory = ts.factory;
+export const createServiceOperationCancelQueriesNodes = () => [
+  factory.createImportDeclaration(
+    undefined,
+    factory.createImportClause(
+      true,
+      undefined,
+      factory.createNamedImports([
+        factory.createImportSpecifier(
+          false,
+          undefined,
+          factory.createIdentifier("QueryFiltersByParameters")
+        ),
+        factory.createImportSpecifier(
+          false,
+          undefined,
+          factory.createIdentifier("QueryFiltersByQueryKey")
+        )
+      ])
+    ),
+    factory.createStringLiteral("@openapi-qraft/tanstack-query-react-types"),
+    undefined
+  ),
+  factory.createImportDeclaration(
+    undefined,
+    factory.createImportClause(
+      true,
+      undefined,
+      factory.createNamedImports([factory.createImportSpecifier(
+        false,
+        undefined,
+        factory.createIdentifier("CancelOptions")
+      )])
+    ),
+    factory.createStringLiteral("@tanstack/query-core"),
+    undefined
+  ),
+  factory.createInterfaceDeclaration(
+    [factory.createToken(ts.SyntaxKind.ExportKeyword)],
+    factory.createIdentifier("ServiceOperationCancelQueries"),
+    [
+      factory.createTypeParameterDeclaration(
+        undefined,
+        factory.createIdentifier("TSchema"),
+        factory.createTypeLiteralNode([
+          factory.createPropertySignature(
+            undefined,
+            factory.createIdentifier("url"),
+            undefined,
+            factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+          ),
+          factory.createPropertySignature(
+            undefined,
+            factory.createIdentifier("method"),
+            undefined,
+            factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+          )
+        ]),
+        undefined
+      ),
+      factory.createTypeParameterDeclaration(
+        undefined,
+        factory.createIdentifier("TQueryFnData"),
+        undefined,
+        undefined
+      ),
+      factory.createTypeParameterDeclaration(
+        undefined,
+        factory.createIdentifier("TParams"),
+        undefined,
+        undefined
+      ),
+      factory.createTypeParameterDeclaration(
+        undefined,
+        factory.createIdentifier("TError"),
+        undefined,
+        undefined
+      )
+    ],
+    undefined,
+    [factory.createMethodSignature(
+      undefined,
+      factory.createIdentifier("cancelQueries"),
+      undefined,
+      [factory.createTypeParameterDeclaration(
+        undefined,
+        factory.createIdentifier("TInfinite"),
+        factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
+        factory.createLiteralTypeNode(factory.createFalse())
+      )],
+      [
+        factory.createParameterDeclaration(
+          undefined,
+          undefined,
+          factory.createIdentifier("filters"),
+          factory.createToken(ts.SyntaxKind.QuestionToken),
+          factory.createUnionTypeNode([
+            factory.createTypeReferenceNode(
+              factory.createIdentifier("QueryFiltersByParameters"),
+              [
+                factory.createTypeReferenceNode(
+                  factory.createIdentifier("TSchema"),
+                  undefined
+                ),
+                factory.createTypeReferenceNode(
+                  factory.createIdentifier("TQueryFnData"),
+                  undefined
+                ),
+                factory.createTypeReferenceNode(
+                  factory.createIdentifier("TInfinite"),
+                  undefined
+                ),
+                factory.createTypeReferenceNode(
+                  factory.createIdentifier("TParams"),
+                  undefined
+                ),
+                factory.createTypeReferenceNode(
+                  factory.createIdentifier("TError"),
+                  undefined
+                )
+              ]
+            ),
+            factory.createTypeReferenceNode(
+              factory.createIdentifier("QueryFiltersByQueryKey"),
+              [
+                factory.createTypeReferenceNode(
+                  factory.createIdentifier("TSchema"),
+                  undefined
+                ),
+                factory.createTypeReferenceNode(
+                  factory.createIdentifier("TQueryFnData"),
+                  undefined
+                ),
+                factory.createTypeReferenceNode(
+                  factory.createIdentifier("TInfinite"),
+                  undefined
+                ),
+                factory.createTypeReferenceNode(
+                  factory.createIdentifier("TParams"),
+                  undefined
+                ),
+                factory.createTypeReferenceNode(
+                  factory.createIdentifier("TError"),
+                  undefined
+                )
+              ]
+            )
+          ]),
+          undefined
+        ),
+        factory.createParameterDeclaration(
+          undefined,
+          undefined,
+          factory.createIdentifier("options"),
+          factory.createToken(ts.SyntaxKind.QuestionToken),
+          factory.createTypeReferenceNode(
+            factory.createIdentifier("CancelOptions"),
+            undefined
+          ),
+          undefined
+        )
+      ],
+      factory.createTypeReferenceNode(
+        factory.createIdentifier("Promise"),
+        [factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword)]
+      )
+    )]
+  )
+];