@openapi-qraft/tanstack-query-react-plugin 1.8.0

package/src/generateCode.ts

@@ -0,0 +1,201 @@
+import { GeneratorFile } from '@openapi-qraft/plugin/lib/GeneratorFile';
+import { Service } from '@openapi-qraft/plugin/lib/open-api/getServices';
+import { OutputOptions as OutputOptionsBase } from '@openapi-qraft/plugin/lib/OutputOptions';
+
+import c from 'ansi-colors';
+import { URL } from 'node:url';
+import { Ora } from 'ora';
+
+import { astToString } from './ts-factory/astToString.js';
+import { getClientFactory } from './ts-factory/getClientFactory.js';
+import { getIndexFactory } from './ts-factory/getIndexFactory.js';
+import {
+  getServiceFactory,
+  ServiceImportsFactoryOptions,
+} from './ts-factory/getServiceFactory.js';
+import { getServiceIndexFactory } from './ts-factory/getServiceIndexFactory.js';
+
+interface OutputOptions extends OutputOptionsBase {
+  fileHeader: string | undefined;
+  servicesDirName: string;
+  explicitImportExtensions: boolean;
+}
+
+export const generateCode = async ({
+  spinner,
+  services,
+  serviceImports,
+  output,
+}: {
+  spinner: Ora;
+  services: Service[];
+  serviceImports: ServiceImportsFactoryOptions;
+  output: OutputOptions;
+}) => {
+  return [
+    ...(await generateServices(spinner, services, serviceImports, output)),
+    ...(await generateServiceIndex(spinner, services, output)),
+    ...(await generateClient(spinner, output)),
+    ...(await generateIndex(spinner, output)),
+  ];
+};
+
+const composeServicesDirPath = (
+  output: Pick<OutputOptions, 'servicesDirName' | 'dir'>
+) => {
+  return new URL(`${output.servicesDirName}/`, output.dir);
+};
+
+const generateServices = async (
+  spinner: Ora,
+  services: Service[],
+  serviceImports: ServiceImportsFactoryOptions,
+  output: OutputOptions
+) => {
+  const servicesDir = composeServicesDirPath(output);
+
+  spinner.start('Generating services');
+
+  const serviceFiles: GeneratorFile[] = [
+    {
+      directory: servicesDir,
+      clean: output.clean,
+    },
+  ];
+
+  for (const service of services) {
+    const { operations, name, typeName, variableName, fileBaseName } = service;
+
+    spinner.text = `Generating ${c.magenta(name)} service`;
+
+    try {
+      const code = astToString(
+        getServiceFactory(
+          {
+            typeName,
+            variableName,
+          },
+          operations,
+          serviceImports
+        )
+      );
+
+      serviceFiles.push({
+        file: new URL(`${fileBaseName}.ts`, servicesDir),
+        code: getFileHeader(output) + code,
+      });
+    } catch (error) {
+      spinner.fail(
+        c.redBright(
+          `Error occurred during ${c.magenta(name)} service generation`
+        )
+      );
+
+      throw error;
+    }
+  }
+
+  spinner.succeed(c.green('Services has been generated'));
+
+  return serviceFiles;
+};
+
+const generateServiceIndex = async (
+  spinner: Ora,
+  services: Service[],
+  output: OutputOptions
+) => {
+  spinner.start('Generating services index');
+
+  const serviceIndexFiles: GeneratorFile[] = [
+    {
+      directory: composeServicesDirPath(output),
+      clean: output.clean,
+    },
+  ];
+
+  try {
+    const code = astToString(
+      getServiceIndexFactory(services, {
+        explicitImportExtensions: Boolean(output.explicitImportExtensions),
+      })
+    );
+
+    serviceIndexFiles.push({
+      file: new URL('index.ts', composeServicesDirPath(output)),
+      code: getFileHeader(output) + code,
+    });
+  } catch (error) {
+    spinner.fail(
+      c.redBright('Error occurred during services index generation')
+    );
+
+    throw error;
+  }
+
+  spinner.succeed(c.green('Services index has been generated'));
+
+  return serviceIndexFiles;
+};
+
+const generateClient = async (spinner: Ora, output: OutputOptions) => {
+  spinner.start('Generating client');
+
+  const clientFiles: GeneratorFile[] = [];
+
+  try {
+    const code = astToString(
+      getClientFactory({
+        servicesDirName: output.servicesDirName,
+        explicitImportExtensions: Boolean(output.explicitImportExtensions),
+      })
+    );
+
+    clientFiles.push({
+      file: new URL('create-api-client.ts', output.dir),
+      code: getFileHeader(output) + code,
+    });
+  } catch (error) {
+    spinner.fail(c.redBright('Error occurred during client generation'));
+
+    throw error;
+  }
+
+  spinner.succeed(c.green('Client has been generated'));
+
+  return clientFiles;
+};
+
+const generateIndex = async (spinner: Ora, output: OutputOptions) => {
+  spinner.start('Generating index');
+
+  const indexFiles: GeneratorFile[] = [];
+
+  try {
+    const code = astToString(
+      getIndexFactory({
+        servicesDirName: output.servicesDirName,
+        explicitImportExtensions: Boolean(output.explicitImportExtensions),
+      })
+    );
+
+    indexFiles.push({
+      file: new URL('index.ts', output.dir),
+      code: getFileHeader(output) + code,
+    });
+  } catch (error) {
+    spinner.fail(c.redBright('Error occurred during index generation'));
+
+    throw error;
+  }
+
+  spinner.succeed(c.green('Index has been generated'));
+
+  return indexFiles;
+};
+
+export const getFileHeader = ({
+  fileHeader,
+}: Pick<OutputOptions, 'fileHeader'>) => {
+  return fileHeader && `${fileHeader}\n`;
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+import { plugin } from './plugin.js';
+
+export default plugin;

package/src/plugin.ts

@@ -0,0 +1,45 @@
+import { fileHeader } from '@openapi-qraft/plugin/lib/fileHeader';
+import { QraftCommand } from '@openapi-qraft/plugin/lib/QraftCommand';
+import { QraftCommandPlugin } from '@openapi-qraft/plugin/lib/QraftCommandPlugin';
+
+import { generateCode } from './generateCode.js';
+
+export const plugin: QraftCommandPlugin = {
+  setupCommand(command: QraftCommand) {
+    command
+      .description('Generate TanStack Query React client from OpenAPI Schema')
+      .requiredOption(
+        '--openapi-types-import-path <path>', // todo::specify better param name to avoid confusion with real path
+        'Path to schema types file (.d.ts), eg: "../openapi.d.ts"'
+      )
+      .option(
+        '--file-header <string>',
+        'Header to be added to the generated file (eg: /* eslint-disable */)'
+      )
+      .option(
+        '--explicit-import-extensions',
+        'All import statements will include explicit `.js` extensions. Ideal for projects using ECMAScript modules.'
+      )
+      .option(
+        '--operation-generics-import-path <path>',
+        'Path to operation generics file',
+        '@openapi-qraft/react'
+      )
+      .action(({ spinner, output, args, services }, resolve) => {
+        return void generateCode({
+          spinner,
+          services,
+          serviceImports: {
+            operationGenericsImportPath: args.operationGenericsImportPath,
+            openapiTypesImportPath: args.openapiTypesImportPath,
+          },
+          output: {
+            ...output,
+            fileHeader: args.fileHeader ?? fileHeader,
+            explicitImportExtensions: args.explicitImportExtensions,
+            servicesDirName: 'services',
+          },
+        }).then(resolve);
+      });
+  },
+};

package/src/ts-factory/astToString.ts

@@ -0,0 +1,34 @@
+import ts from 'typescript';
+
+export interface AstToStringOptions {
+  fileName?: string;
+  sourceText?: string;
+  formatOptions?: ts.PrinterOptions;
+}
+
+/** Convert TypeScript AST to string */
+export function astToString(
+  ast: ts.Node | ts.Node[] | ts.TypeElement | ts.TypeElement[],
+  options?: AstToStringOptions
+): string {
+  const sourceFile = ts.createSourceFile(
+    options?.fileName ?? 'openapi-ts.ts',
+    options?.sourceText ?? '',
+    ts.ScriptTarget.ESNext,
+    false,
+    ts.ScriptKind.TS
+  );
+
+  // @ts-expect-error it’s OK to overwrite statements once
+  sourceFile.statements = ts.factory.createNodeArray(
+    Array.isArray(ast) ? ast : [ast]
+  );
+
+  const printer = ts.createPrinter({
+    newLine: ts.NewLineKind.LineFeed,
+    removeComments: false,
+    ...options?.formatOptions,
+  });
+
+  return printer.printFile(sourceFile);
+}

package/src/ts-factory/getClientFactory.ts

@@ -0,0 +1,207 @@
+import ts from 'typescript';
+
+type Options = {
+  servicesDirName: string;
+  explicitImportExtensions: boolean;
+};
+
+export const getClientFactory = (options: Options) => {
+  return [
+    ...getClientImportsFactory(options),
+    getCallbacksVariableFactory(),
+    getCreateClientFunctionFactory(),
+  ];
+};
+
+const getClientImportsFactory = ({
+  servicesDirName,
+  explicitImportExtensions,
+}: Options) => {
+  const factory = ts.factory;
+
+  return [
+    factory.createImportDeclaration(
+      undefined,
+      factory.createImportClause(
+        false,
+        undefined,
+        factory.createNamedImports([
+          factory.createImportSpecifier(
+            false,
+            undefined,
+            factory.createIdentifier('qraftAPIClient')
+          ),
+          factory.createImportSpecifier(
+            false,
+            undefined,
+            factory.createIdentifier('QraftClientOptions')
+          ),
+        ])
+      ),
+      factory.createStringLiteral('@openapi-qraft/react'),
+      undefined
+    ),
+    ...serviceCallbacks.map((propertyName) =>
+      factory.createImportDeclaration(
+        undefined,
+        factory.createImportClause(
+          false,
+          undefined,
+          factory.createNamedImports([
+            factory.createImportSpecifier(
+              false,
+              undefined,
+              factory.createIdentifier(propertyName)
+            ),
+          ])
+        ),
+        factory.createStringLiteral(
+          `@openapi-qraft/react/callbacks/${propertyName}`
+        ),
+        undefined
+      )
+    ),
+    factory.createImportDeclaration(
+      undefined,
+      factory.createImportClause(
+        false,
+        undefined,
+        factory.createNamedImports([
+          factory.createImportSpecifier(
+            false,
+            undefined,
+            factory.createIdentifier('services')
+          ),
+          factory.createImportSpecifier(
+            false,
+            undefined,
+            factory.createIdentifier('Services')
+          ),
+        ])
+      ),
+      factory.createStringLiteral(
+        `./${servicesDirName}/index${explicitImportExtensions ? '.js' : ''}`
+      ),
+      undefined
+    ),
+  ];
+};
+
+const getCallbacksVariableFactory = () => {
+  const factory = ts.factory;
+
+  return factory.createVariableStatement(
+    undefined,
+    factory.createVariableDeclarationList(
+      [
+        factory.createVariableDeclaration(
+          factory.createIdentifier('callbacks'),
+          undefined,
+          undefined,
+          factory.createObjectLiteralExpression(
+            serviceCallbacks.map((propertyName) =>
+              factory.createShorthandPropertyAssignment(
+                factory.createIdentifier(propertyName),
+                undefined
+              )
+            ),
+            true
+          )
+        ),
+      ],
+      ts.NodeFlags.Const
+    )
+  );
+};
+
+const getCreateClientFunctionFactory = () => {
+  const factory = ts.factory;
+
+  return factory.createFunctionDeclaration(
+    [factory.createToken(ts.SyntaxKind.ExportKeyword)],
+    undefined,
+    factory.createIdentifier('createAPIClient'),
+    undefined,
+    [
+      factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        factory.createIdentifier('options'),
+        factory.createToken(ts.SyntaxKind.QuestionToken),
+        factory.createTypeReferenceNode(
+          factory.createIdentifier('QraftClientOptions'),
+          undefined
+        ),
+        undefined
+      ),
+    ],
+    factory.createTypeReferenceNode(
+      factory.createIdentifier('Services'),
+      undefined
+    ),
+    factory.createBlock(
+      [
+        factory.createReturnStatement(
+          factory.createCallExpression(
+            factory.createIdentifier('qraftAPIClient'),
+            [
+              factory.createTypeReferenceNode(
+                factory.createIdentifier('Services'),
+                undefined
+              ),
+              factory.createTypeQueryNode(
+                factory.createIdentifier('callbacks'),
+                undefined
+              ),
+            ],
+            [
+              factory.createIdentifier('services'),
+              factory.createIdentifier('callbacks'),
+              factory.createIdentifier('options'),
+            ]
+          )
+        ),
+      ],
+      true
+    )
+  );
+};
+
+// todo::make callbacks type-safe
+const serviceCallbacks = [
+  'getInfiniteQueryData',
+  'getInfiniteQueryKey',
+  'getMutationKey',
+  'getQueryData',
+  'getQueriesData',
+  'getQueryKey',
+  'mutationFn',
+  'queryFn',
+  'setInfiniteQueryData',
+  'setQueryData',
+  'setQueriesData',
+  'useInfiniteQuery',
+  'useMutation',
+  'useQuery',
+  'useSuspenseQuery',
+  'useSuspenseInfiniteQuery',
+  'useMutationState',
+  'useIsMutating',
+  'useQueries',
+  'useSuspenseQueries',
+  'invalidateQueries',
+  'cancelQueries',
+  'resetQueries',
+  'removeQueries',
+  'refetchQueries',
+  'isFetching',
+  'isMutating',
+  'useIsFetching',
+  'fetchQuery',
+  'prefetchQuery',
+  'fetchInfiniteQuery',
+  'prefetchInfiniteQuery',
+  'getQueryState',
+  'getInfiniteQueryState',
+  'operationInvokeFn',
+] as const;

package/src/ts-factory/getIndexFactory.ts

@@ -0,0 +1,58 @@
+import ts from 'typescript';
+
+export const getIndexFactory = ({
+  servicesDirName,
+  explicitImportExtensions,
+}: {
+  servicesDirName: string;
+  explicitImportExtensions: boolean;
+}) => {
+  const factory = ts.factory;
+  const importExtension = explicitImportExtensions ? '.js' : '';
+
+  return [
+    factory.createExportDeclaration(
+      undefined,
+      false,
+      factory.createNamedExports([
+        factory.createExportSpecifier(
+          false,
+          undefined,
+          factory.createIdentifier('services')
+        ),
+      ]),
+      factory.createStringLiteral(
+        `./${servicesDirName}/index${importExtension}`
+      ),
+      undefined
+    ),
+    factory.createExportDeclaration(
+      undefined,
+      true,
+      factory.createNamedExports([
+        factory.createExportSpecifier(
+          false,
+          undefined,
+          factory.createIdentifier('Services')
+        ),
+      ]),
+      factory.createStringLiteral(
+        `./${servicesDirName}/index${importExtension}`
+      ),
+      undefined
+    ),
+    factory.createExportDeclaration(
+      undefined,
+      false,
+      factory.createNamedExports([
+        factory.createExportSpecifier(
+          false,
+          undefined,
+          factory.createIdentifier('createAPIClient')
+        ),
+      ]),
+      factory.createStringLiteral(`./create-api-client${importExtension}`),
+      undefined
+    ),
+  ];
+};