feat: generate fetchers only (#22)

* Extract getOperationTypes

* Extract createOpertaionFetcherFnNodes

* Add `generateFetchers` generator

* Fix import config path resolution on linux

* Add fetcher import declaration

* Remove broken command

Author: fabien0102

cli/package.json

@@ -24,7 +24,6 @@
   ],
   "license": "MIT",
   "scripts": {
-    "start": "node -r @swc-node/register src/cli.ts",
     "build": "tsc -p tsconfig.package.json",
     "prepublishOnly": "npm run build"
   },

cli/src/commands/GenerateCommand.ts

@@ -58,7 +58,7 @@ export class GenerateCommand extends Command {
 
       // Compute the result
       const { default: config } = await import(
-        path.relative(slash(__filename), slash(transpiledPath).slice(3))
+        path.relative(path.parse(slash(__filename)).dir, slash(transpiledPath))
       );
 
       // Delete the transpiled file
@@ -68,7 +68,7 @@ export class GenerateCommand extends Command {
       return config;
     } else {
       return await import(
-        path.relative(slash(__filename), slash(userConfigPath)).slice(3)
+        path.relative(path.parse(slash(__filename)).dir, slash(userConfigPath))
       );
     }
   }

plugins/typescript/README.md

@@ -100,6 +100,12 @@ export const useBadassContext = (): BadassContext => {
 
 You can also tweak `{filenamePrefix}Fetcher.ts`, especially the error management part, so everything fit the expected `ErrorType`.
 
+### generateFetchers
+
+Generate some generic fetchers, `{filenamePrefix}Fetcher.ts` can be customized to fit your needs.
+
+`{filenamePrefix}Components.ts` will use this fetcher with the OpenAPI types passed as generic.
+
 ## Utils
 
 ### renameComponent

plugins/typescript/src/core/createNamedImport.ts

@@ -0,0 +1,30 @@
+import { factory as f } from "typescript";
+
+/**
+ * Helper to create named imports.
+ *
+ * @param fnName functions to imports
+ * @param filename path of the module
+ * @returns ts.Node of the import declaration
+ */
+export const createNamedImport = (
+  fnName: string | string[],
+  filename: string
+) => {
+  const fnNames = Array.isArray(fnName) ? fnName : [fnName];
+  return f.createImportDeclaration(
+    undefined,
+    undefined,
+    f.createImportClause(
+      false,
+      undefined,
+      f.createNamedImports(
+        fnNames.map((name) =>
+          f.createImportSpecifier(false, undefined, f.createIdentifier(name))
+        )
+      )
+    ),
+    f.createStringLiteral(filename),
+    undefined
+  );
+};

plugins/typescript/src/core/createOperationFetcherFnNodes.ts

@@ -0,0 +1,116 @@
+import { camel } from "case";
+import { OperationObject } from "openapi3-ts";
+import ts, { factory as f } from "typescript";
+
+/**
+ * Create the declaration of the fetcher function.
+ *
+ * @returns Array of nodes
+ */
+export const createOperationFetcherFnNodes = ({
+  dataType,
+  requestBodyType,
+  queryParamsType,
+  pathParamsType,
+  headersType,
+  variablesType,
+  fetcherFn,
+  operation,
+  url,
+  verb,
+  name,
+}: {
+  dataType: ts.TypeNode;
+  requestBodyType: ts.TypeNode;
+  headersType: ts.TypeNode;
+  pathParamsType: ts.TypeNode;
+  queryParamsType: ts.TypeNode;
+  variablesType: ts.TypeNode;
+  operation: OperationObject;
+  fetcherFn: string;
+  url: string;
+  verb: string;
+  name: string;
+}) => {
+  const nodes: ts.Node[] = [];
+  if (operation.description) {
+    nodes.push(f.createJSDocComment(operation.description.trim(), []));
+  }
+
+  nodes.push(
+    f.createVariableStatement(
+      [f.createModifier(ts.SyntaxKind.ExportKeyword)],
+      f.createVariableDeclarationList(
+        [
+          f.createVariableDeclaration(
+            f.createIdentifier(name),
+            undefined,
+            undefined,
+            f.createArrowFunction(
+              undefined,
+              undefined,
+              variablesType.kind !== ts.SyntaxKind.VoidKeyword
+                ? [
+                    f.createParameterDeclaration(
+                      undefined,
+                      undefined,
+                      undefined,
+                      f.createIdentifier("variables"),
+                      undefined,
+                      variablesType,
+                      undefined
+                    ),
+                  ]
+                : [],
+              undefined,
+              f.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+              f.createCallExpression(
+                f.createIdentifier(fetcherFn),
+                [
+                  dataType,
+                  requestBodyType,
+                  headersType,
+                  queryParamsType,
+                  pathParamsType,
+                ],
+                [
+                  f.createObjectLiteralExpression(
+                    [
+                      f.createPropertyAssignment(
+                        f.createIdentifier("url"),
+                        f.createStringLiteral(camelizedPathParams(url))
+                      ),
+                      f.createPropertyAssignment(
+                        f.createIdentifier("method"),
+                        f.createStringLiteral(verb)
+                      ),
+                      ...(variablesType.kind !== ts.SyntaxKind.VoidKeyword
+                        ? [
+                            f.createSpreadAssignment(
+                              f.createIdentifier("variables")
+                            ),
+                          ]
+                        : []),
+                    ],
+                    false
+                  ),
+                ]
+              )
+            )
+          ),
+        ],
+        ts.NodeFlags.Const
+      )
+    )
+  );
+  return nodes;
+};
+
+/**
+ * Transform url params case to camel.
+ *
+ * @example
+ * `pet/{pet_id}` -> `pet/{petId}`
+ */
+const camelizedPathParams = (url: string) =>
+  url.replace(/\{\w*\}/g, (match) => `{${camel(match)}}`);