@openapi-qraft/tanstack-query-react-plugin 2.0.0-next.0 → 2.0.0-next.10

package/src/lib/createOperationCommonTSDoc.ts

@@ -0,0 +1,11 @@
+import { ServiceOperation } from '@openapi-qraft/plugin/lib/open-api/getServices';
+
+export const createOperationCommonTSDoc = (operation: ServiceOperation) => {
+  return [
+    operation.deprecated ? '@deprecated' : null,
+    operation.summary ? `@summary ${operation.summary}` : null,
+    operation.description ? `@description ${operation.description}` : null,
+  ].filter((comment): comment is NonNullable<typeof comment> =>
+    Boolean(comment)
+  );
+};

package/src/lib/maybeResolveImport.ts

@@ -0,0 +1,19 @@
+/**
+ * Prepend the import path if it's a relative path.
+ * Normally,`openapiTypesImportPath` is a relative path to the services' directory.
+ */
+export function maybeResolveImport<T extends string | undefined>({
+  openapiTypesImportPath,
+  servicesDirName,
+}: {
+  openapiTypesImportPath: T;
+  servicesDirName: string;
+}) {
+  if (openapiTypesImportPath?.startsWith('../')) {
+    return `./${openapiTypesImportPath.slice(3)}`;
+  } else if (openapiTypesImportPath?.startsWith('./')) {
+    return `./${servicesDirName}/${openapiTypesImportPath.slice(2)}`;
+  }
+
+  return openapiTypesImportPath;
+}

package/src/plugin.ts

@@ -1,4 +1,8 @@
 import { fileHeader } from '@openapi-qraft/plugin/lib/fileHeader';
+import {
+  createPredefinedParametersGlobs,
+  parseOperationPredefinedParametersOption,
+} from '@openapi-qraft/plugin/lib/predefineSchemaParameters';
 import { QraftCommand } from '@openapi-qraft/plugin/lib/QraftCommand';
 import { QraftCommandPlugin } from '@openapi-qraft/plugin/lib/QraftCommandPlugin';
 import { generateCode } from './generateCode.js';
@@ -22,17 +26,11 @@ export const plugin: QraftCommandPlugin = {
           return arg?.toLowerCase() !== 'false';
         }
       )
-      .option(
-        '--operation-generics-import-path <path>',
-        'Path to operation generics file',
-        '@openapi-qraft/react'
-      )
-      .action(async ({ spinner, output, args, services }, resolve) => {
+      .action(async ({ spinner, output, args, services, schema }, resolve) => {
         return void (await generateCode({
           spinner,
           services,
           serviceImports: {
-            operationGenericsImportPath: args.operationGenericsImportPath,
             openapiTypesImportPath: args.openapiTypesImportPath,
           },
           output: {
@@ -41,6 +39,14 @@ export const plugin: QraftCommandPlugin = {
             explicitImportExtensions: args.explicitImportExtensions,
             servicesDirName: 'services',
             exportSchemaTypes: args.exportOpenapiTypes,
+            operationPredefinedParameters: args.operationPredefinedParameters
+              ? createPredefinedParametersGlobs(
+                  schema,
+                  parseOperationPredefinedParametersOption(
+                    ...args.operationPredefinedParameters
+                  )
+                )
+              : undefined, // inherited from `--operation-predefined-parameters` option
           },
         }).then(resolve));
       });

package/src/ts-factory/getClientFactory.ts

@@ -32,6 +32,9 @@ const getClientImportsFactory = ({
           ),
           ...[
             'APIBasicClientServices',
+            'APIBasicQueryClientServices',
+            'APIUtilityClientServices',
+            'CreateAPIBasicQueryClientOptions',
             'CreateAPIBasicClientOptions',
             'CreateAPIClientOptions',
             'CreateAPIQueryClientOptions',
@@ -111,6 +114,39 @@ const getCreateClientFunctionFactory = () => {
       ),
       undefined
     ),
+    factory.createFunctionDeclaration(
+      [factory.createToken(ts.SyntaxKind.ExportKeyword)],
+      undefined,
+      factory.createIdentifier('createAPIClient'),
+      undefined,
+      [
+        factory.createParameterDeclaration(
+          undefined,
+          undefined,
+          factory.createIdentifier('options'),
+          undefined,
+          factory.createTypeReferenceNode(
+            factory.createIdentifier('CreateAPIBasicQueryClientOptions'),
+            undefined
+          ),
+          undefined
+        ),
+      ],
+      factory.createTypeReferenceNode(
+        factory.createIdentifier('APIBasicQueryClientServices'),
+        [
+          factory.createTypeReferenceNode(
+            factory.createIdentifier('Services'),
+            undefined
+          ),
+          factory.createTypeReferenceNode(
+            factory.createIdentifier('ServiceMethods'),
+            undefined
+          ),
+        ]
+      ),
+      undefined
+    ),
     factory.createFunctionDeclaration(
       [factory.createToken(ts.SyntaxKind.ExportKeyword)],
       undefined,
@@ -144,6 +180,27 @@ const getCreateClientFunctionFactory = () => {
       ),
       undefined
     ),
+    factory.createFunctionDeclaration(
+      [factory.createToken(ts.SyntaxKind.ExportKeyword)],
+      undefined,
+      factory.createIdentifier('createAPIClient'),
+      undefined,
+      [],
+      factory.createTypeReferenceNode(
+        factory.createIdentifier('APIUtilityClientServices'),
+        [
+          factory.createTypeReferenceNode(
+            factory.createIdentifier('Services'),
+            undefined
+          ),
+          factory.createTypeReferenceNode(
+            factory.createIdentifier('ServiceMethods'),
+            undefined
+          ),
+        ]
+      ),
+      undefined
+    ),
     factory.createFunctionDeclaration(
       [factory.createToken(ts.SyntaxKind.ExportKeyword)],
       undefined,
@@ -154,7 +211,7 @@ const getCreateClientFunctionFactory = () => {
           undefined,
           undefined,
           factory.createIdentifier('options'),
-          undefined,
+          factory.createToken(ts.SyntaxKind.QuestionToken),
           factory.createTypeReferenceNode(
             factory.createIdentifier('CreateAPIClientOptions'),
             undefined
@@ -180,9 +237,76 @@ const getCreateClientFunctionFactory = () => {
             ),
           ]
         ),
+        factory.createTypeReferenceNode(
+          factory.createIdentifier('APIUtilityClientServices'),
+          [
+            factory.createTypeReferenceNode(
+              factory.createIdentifier('Services'),
+              undefined
+            ),
+            factory.createTypeReferenceNode(
+              factory.createIdentifier('ServiceMethods'),
+              undefined
+            ),
+          ]
+        ),
       ]),
       factory.createBlock(
         [
+          factory.createIfStatement(
+            factory.createPrefixUnaryExpression(
+              ts.SyntaxKind.ExclamationToken,
+              factory.createIdentifier('options')
+            ),
+            factory.createReturnStatement(
+              factory.createCallExpression(
+                factory.createIdentifier('qraftAPIClient'),
+                [
+                  factory.createTypeReferenceNode(
+                    factory.createIdentifier('Services'),
+                    undefined
+                  ),
+                  factory.createTypeReferenceNode(
+                    factory.createIdentifier('ServiceMethods'),
+                    undefined
+                  ),
+                ],
+                [
+                  factory.createIdentifier('services'),
+                  factory.createIdentifier('callbacks'),
+                ]
+              )
+            ),
+            undefined
+          ),
+          factory.createIfStatement(
+            factory.createBinaryExpression(
+              factory.createStringLiteral('requestFn'),
+              factory.createToken(ts.SyntaxKind.InKeyword),
+              factory.createIdentifier('options')
+            ),
+            factory.createReturnStatement(
+              factory.createCallExpression(
+                factory.createIdentifier('qraftAPIClient'),
+                [
+                  factory.createTypeReferenceNode(
+                    factory.createIdentifier('Services'),
+                    undefined
+                  ),
+                  factory.createTypeReferenceNode(
+                    factory.createIdentifier('ServiceMethods'),
+                    undefined
+                  ),
+                ],
+                [
+                  factory.createIdentifier('services'),
+                  factory.createIdentifier('callbacks'),
+                  factory.createIdentifier('options'),
+                ]
+              )
+            ),
+            undefined
+          ),
           factory.createReturnStatement(
             factory.createCallExpression(
               factory.createIdentifier('qraftAPIClient'),

package/src/ts-factory/getCreatePredefinedParametersRequestFnFactory.ts

@@ -0,0 +1,346 @@
+import { PredefinedParametersGlob } from '@openapi-qraft/plugin/lib/predefineSchemaParameters';
+import ts from 'typescript';
+import { maybeResolveImport } from '../lib/maybeResolveImport.js';
+
+type Options = {
+  servicesDirName: string;
+  operationPredefinedParameters: Array<PredefinedParametersGlob> | undefined;
+  openapiTypesImportPath: string | undefined;
+};
+
+export const getCreatePredefinedParametersRequestFnFactory = (
+  options: Options
+) => {
+  if (!options.openapiTypesImportPath) return [];
+  if (!options.operationPredefinedParameters?.length) return [];
+
+  return [
+    ...getCreatePredefinedParametersRequestFnImportsFactory(options),
+    ...getCreatePredefinedParametersRequestFnTypesFactory(options),
+    ...getCreatePredefinedParametersRequestFnVariablesFactory(options),
+    ...getCreatePredefinedParametersRequestFnFunctionFactory(options),
+  ];
+};
+
+const getCreatePredefinedParametersRequestFnImportsFactory = ({
+  servicesDirName,
+  openapiTypesImportPath,
+}: Options) => {
+  if (!openapiTypesImportPath) return [];
+
+  const factory = ts.factory;
+
+  return [
+    factory.createImportDeclaration(
+      undefined,
+      factory.createImportClause(
+        true,
+        undefined,
+        factory.createNamedImports([
+          factory.createImportSpecifier(
+            false,
+            undefined,
+            factory.createIdentifier('RequestFn')
+          ),
+        ])
+      ),
+      factory.createStringLiteral('@openapi-qraft/react'),
+      undefined
+    ),
+    factory.createImportDeclaration(
+      undefined,
+      factory.createImportClause(
+        false,
+        undefined,
+        factory.createNamedImports([
+          factory.createImportSpecifier(
+            false,
+            undefined,
+            factory.createIdentifier('qraftPredefinedParametersRequestFn')
+          ),
+          factory.createImportSpecifier(
+            true,
+            undefined,
+            factory.createIdentifier('QraftPredefinedParameterValue')
+          ),
+        ])
+      ),
+      factory.createStringLiteral(
+        '@openapi-qraft/react/qraftPredefinedParametersRequestFn'
+      ),
+      undefined
+    ),
+    factory.createImportDeclaration(
+      undefined,
+      factory.createImportClause(
+        true,
+        undefined,
+        factory.createNamedImports([
+          factory.createImportSpecifier(
+            false,
+            undefined,
+            factory.createIdentifier('paths')
+          ),
+        ])
+      ),
+      factory.createStringLiteral(
+        maybeResolveImport({ openapiTypesImportPath, servicesDirName })
+      ),
+      undefined
+    ),
+  ];
+};
+
+const getCreatePredefinedParametersRequestFnTypesFactory = ({
+  operationPredefinedParameters,
+}: Options) => {
+  if (!operationPredefinedParameters) return [];
+
+  const factory = ts.factory;
+
+  return [
+    factory.createTypeAliasDeclaration(
+      [factory.createToken(ts.SyntaxKind.ExportKeyword)],
+      factory.createIdentifier('ServiceOperationsPredefinedParameters'),
+      undefined,
+      factory.createTupleTypeNode(
+        operationPredefinedParameters.map((item) => {
+          return factory.createTypeLiteralNode([
+            factory.createPropertySignature(
+              undefined,
+              factory.createIdentifier('requestPattern'),
+              undefined,
+              factory.createLiteralTypeNode(
+                factory.createStringLiteral(
+                  `${item.methods.join(',')} ${item.pathGlobs}`
+                )
+              )
+            ),
+            factory.createPropertySignature(
+              undefined,
+              factory.createIdentifier('parameters'),
+              undefined,
+              factory.createTupleTypeNode(
+                item.parameters.map((parameter) =>
+                  factory.createTypeLiteralNode([
+                    factory.createPropertySignature(
+                      undefined,
+                      factory.createIdentifier('in'),
+                      undefined,
+                      factory.createLiteralTypeNode(
+                        factory.createStringLiteral(parameter.in)
+                      )
+                    ),
+                    factory.createPropertySignature(
+                      undefined,
+                      factory.createIdentifier('name'),
+                      undefined,
+                      factory.createLiteralTypeNode(
+                        factory.createStringLiteral(parameter.name)
+                      )
+                    ),
+                    factory.createPropertySignature(
+                      undefined,
+                      factory.createIdentifier('value'),
+                      undefined,
+                      factory.createTypeReferenceNode(
+                        factory.createIdentifier(
+                          'QraftPredefinedParameterValue'
+                        ),
+                        [
+                          factory.createIndexedAccessTypeNode(
+                            factory.createTypeReferenceNode(
+                              factory.createIdentifier('NonNullable'),
+                              [
+                                factory.createIndexedAccessTypeNode(
+                                  factory.createIndexedAccessTypeNode(
+                                    factory.createIndexedAccessTypeNode(
+                                      factory.createIndexedAccessTypeNode(
+                                        factory.createTypeReferenceNode(
+                                          factory.createIdentifier('paths'),
+                                          undefined
+                                        ),
+                                        factory.createLiteralTypeNode(
+                                          factory.createStringLiteral(
+                                            item.paths[0]
+                                          )
+                                        )
+                                      ),
+                                      factory.createLiteralTypeNode(
+                                        factory.createStringLiteral(
+                                          item.methods ? item.methods[0] : 'get'
+                                        )
+                                      )
+                                    ),
+                                    factory.createLiteralTypeNode(
+                                      factory.createStringLiteral('parameters')
+                                    )
+                                  ),
+                                  factory.createLiteralTypeNode(
+                                    factory.createStringLiteral(parameter.in)
+                                  )
+                                ),
+                              ]
+                            ),
+                            factory.createLiteralTypeNode(
+                              factory.createStringLiteral(parameter.name)
+                            )
+                          ),
+                        ]
+                      )
+                    ),
+                  ])
+                )
+              )
+            ),
+          ]);
+        })
+      )
+    ),
+  ];
+};
+const getCreatePredefinedParametersRequestFnVariablesFactory = ({
+  operationPredefinedParameters,
+}: Options) => {
+  if (!operationPredefinedParameters) return [];
+
+  const factory = ts.factory;
+
+  return [
+    factory.createVariableStatement(
+      [factory.createToken(ts.SyntaxKind.ExportKeyword)],
+      factory.createVariableDeclarationList(
+        [
+          factory.createVariableDeclaration(
+            factory.createIdentifier('serviceOperationsPredefinedParameters'),
+            undefined,
+            undefined,
+            factory.createAsExpression(
+              factory.createArrayLiteralExpression(
+                operationPredefinedParameters.map((item) =>
+                  factory.createObjectLiteralExpression(
+                    [
+                      factory.createPropertyAssignment(
+                        factory.createIdentifier('requestPattern'),
+                        factory.createStringLiteral(
+                          `${item.methods.join(',')} ${item.pathGlobs}`
+                        )
+                      ),
+                      factory.createPropertyAssignment(
+                        factory.createIdentifier('methods'),
+                        factory.createArrayLiteralExpression(
+                          item.methods.map((method) =>
+                            factory.createStringLiteral(method)
+                          ),
+                          false
+                        )
+                      ),
+                      factory.createPropertyAssignment(
+                        factory.createIdentifier('paths'),
+                        factory.createArrayLiteralExpression(
+                          item.paths.map((path) =>
+                            factory.createStringLiteral(path)
+                          ),
+                          true
+                        )
+                      ),
+                    ],
+                    true
+                  )
+                ),
+                true
+              ),
+              factory.createTypeReferenceNode(
+                factory.createIdentifier('const'),
+                undefined
+              )
+            )
+          ),
+        ],
+        ts.NodeFlags.Const
+      )
+    ),
+  ];
+};
+
+const getCreatePredefinedParametersRequestFnFunctionFactory = ({
+  operationPredefinedParameters,
+}: Options) => {
+  if (!operationPredefinedParameters) return [];
+
+  const factory = ts.factory;
+
+  return [
+    factory.createFunctionDeclaration(
+      [factory.createToken(ts.SyntaxKind.ExportKeyword)],
+      undefined,
+      factory.createIdentifier('createPredefinedParametersRequestFn'),
+      [
+        factory.createTypeParameterDeclaration(
+          undefined,
+          factory.createIdentifier('TRequestFn'),
+          factory.createTypeReferenceNode(
+            factory.createIdentifier('RequestFn'),
+            [
+              factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+              factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+            ]
+          ),
+          undefined
+        ),
+      ],
+      [
+        factory.createParameterDeclaration(
+          undefined,
+          undefined,
+          factory.createIdentifier('predefinedParameters'),
+          undefined,
+          factory.createTypeReferenceNode(
+            factory.createIdentifier('ServiceOperationsPredefinedParameters'),
+            undefined
+          ),
+          undefined
+        ),
+        factory.createParameterDeclaration(
+          undefined,
+          undefined,
+          factory.createIdentifier('requestFn'),
+          undefined,
+          factory.createTypeReferenceNode(
+            factory.createIdentifier('TRequestFn'),
+            undefined
+          ),
+          undefined
+        ),
+      ],
+      factory.createTypeReferenceNode(
+        factory.createIdentifier('TRequestFn'),
+        undefined
+      ),
+      factory.createBlock(
+        [
+          factory.createReturnStatement(
+            factory.createAsExpression(
+              factory.createCallExpression(
+                factory.createIdentifier('qraftPredefinedParametersRequestFn'),
+                undefined,
+                [
+                  factory.createIdentifier('predefinedParameters'),
+                  factory.createIdentifier(
+                    'serviceOperationsPredefinedParameters'
+                  ),
+                  factory.createIdentifier('requestFn'),
+                ]
+              ),
+              factory.createTypeReferenceNode(
+                factory.createIdentifier('TRequestFn'),
+                undefined
+              )
+            )
+          ),
+        ],
+        true
+      )
+    ),
+  ];
+};

package/src/ts-factory/getIndexFactory.ts

@@ -1,5 +1,6 @@
 import type { ServiceImportsFactoryOptions } from './getServiceFactory.js';
 import ts from 'typescript';
+import { maybeResolveImport } from '../lib/maybeResolveImport.js';
 
 export const getIndexFactory = ({
   openapiTypesImportPath,
@@ -71,23 +72,3 @@ export const getIndexFactory = ({
     ),
   ];
 };
-
-/**
- * Prepend the import path if it's a relative path.
- * Normally,`openapiTypesImportPath` is a relative path to the services' directory.
- */
-export function maybeResolveImport<T extends string | undefined>({
-  openapiTypesImportPath,
-  servicesDirName,
-}: {
-  openapiTypesImportPath: T;
-  servicesDirName: string;
-}) {
-  if (openapiTypesImportPath?.startsWith('../')) {
-    return `./${openapiTypesImportPath.slice(3)}`;
-  } else if (openapiTypesImportPath?.startsWith('./')) {
-    return `./${servicesDirName}/${openapiTypesImportPath.slice(2)}`;
-  }
-
-  return openapiTypesImportPath;
-}