@7nohe/openapi-react-query-codegen 1.0.6 → 1.1.0

package/README.md

@@ -46,7 +46,7 @@ Options:
   -c, --client <value>       HTTP client to generate [fetch, xhr, node, axios, angular] (default: "fetch")
   --request <value>          Path to custom request file
   --useDateType              Use Date type instead of string for date types for models, this will not convert the data to a Date object
-  --enums                    Generate JavaScript objects from enum definitions?
+  --enums <value>            Generate JavaScript objects from enum definitions? ['javascript', 'typescript']
   --base <value>             Manually set base in OpenAPI config instead of inferring from server value
   --serviceResponse <value>  Define shape of returned value from service calls ['body', 'generics', 'response']
   --operationId              Use operation ID to generate operation names?

package/dist/cli.mjs

@@ -26,10 +26,10 @@ async function setupProgram() {
         .option("--operationId", "Use operation ID to generate operation names?")
         .addOption(new Option("--serviceResponse <value>", "Define shape of returned value from service calls").choices(["body", "generics", "response"]))
         .option("--base <value>", "Manually set base in OpenAPI config instead of inferring from server value")
-        .option("--enums", "Generate JavaScript objects from enum definitions?")
+        .addOption(new Option("--enums <value>", "Generate JavaScript objects from enum definitions?").choices(["javascript", "typescript"]))
         .option("--useDateType", "Use Date type instead of string for date types for models, this will not convert the data to a Date object")
         .parse();
     const options = program.opts();
-    generate(options, version);
+    await generate(options, version);
 }
 setupProgram();

package/dist/createExports.mjs

@@ -3,10 +3,23 @@ import { createUseMutation } from "./createUseMutation.mjs";
 export const createExports = (service) => {
     const { klasses } = service;
     const methods = klasses.map((k) => k.methods).flat();
-    const allGet = methods.filter((m) => m.httpMethodName === "'GET'");
-    const allPost = methods.filter((m) => m.httpMethodName === "'POST'");
-    const allQueries = allGet.map((m) => createUseQuery(m));
-    const allMutations = allPost.map((m) => createUseMutation(m));
+    const allGet = methods.filter((m) => m.httpMethodName.toUpperCase().includes("GET"));
+    const allPost = methods.filter((m) => m.httpMethodName.toUpperCase().includes("POST"));
+    const allPut = methods.filter((m) => m.httpMethodName.toUpperCase().includes("PUT"));
+    const allPatch = methods.filter((m) => m.httpMethodName.toUpperCase().includes("PATCH"));
+    const allDelete = methods.filter((m) => m.httpMethodName.toUpperCase().includes("DELETE"));
+    const allGetQueries = allGet.map((m) => createUseQuery(m));
+    const allPostMutations = allPost.map((m) => createUseMutation(m));
+    const allPutMutations = allPut.map((m) => createUseMutation(m));
+    const allPatchMutations = allPatch.map((m) => createUseMutation(m));
+    const allDeleteMutations = allDelete.map((m) => createUseMutation(m));
+    const allQueries = [...allGetQueries];
+    const allMutations = [
+        ...allPostMutations,
+        ...allPutMutations,
+        ...allPatchMutations,
+        ...allDeleteMutations,
+    ];
     const commonInQueries = allQueries
         .map(({ apiResponse, returnType, key }) => [apiResponse, returnType, key])
         .flat();

package/dist/createImports.mjs

@@ -1,12 +1,7 @@
 import ts from "typescript";
 import { posix } from "path";
 const { join } = posix;
-export const createImports = ({ service, serviceEndName, project, }) => {
-    const { klasses } = service;
-    // get all class names
-    const classNames = klasses.map(({ className }) => className);
-    // remove duplicates
-    const uniqueClassNames = [...new Set(classNames)];
+export const createImports = ({ serviceEndName, project, }) => {
     const modelsFile = project
         .getSourceFiles()
         .find((sourceFile) => sourceFile.getFilePath().includes("models.ts"));
@@ -14,16 +9,20 @@ export const createImports = ({ service, serviceEndName, project, }) => {
         .getSourceFiles()
         .find((sourceFile) => sourceFile.getFilePath().includes("services.ts"));
     if (!modelsFile) {
-        throw new Error("No models file found");
+        console.warn(`
+⚠️ WARNING: No models file found.
+  This may be an error if \`.components.schemas\` or \`.components.parameters\` is defined in your OpenAPI input.`);
     }
     if (!serviceFile) {
         throw new Error("No service file found");
     }
-    const modalNames = Array.from(modelsFile.getExportedDeclarations().keys());
+    const modelNames = modelsFile
+        ? Array.from(modelsFile.getExportedDeclarations().keys())
+        : [];
     const serviceExports = Array.from(serviceFile.getExportedDeclarations().keys());
     const serviceNames = serviceExports.filter((name) => name.endsWith(serviceEndName));
     const serviceNamesData = serviceExports.filter((name) => name.endsWith("Data"));
-    return [
+    const imports = [
         ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
             ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("useQuery")),
             ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("useSuspenseQuery")),
@@ -39,9 +38,12 @@ export const createImports = ({ service, serviceEndName, project, }) => {
             // import all data objects from service file
             ...serviceNamesData.map((dataName) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(dataName))),
         ])), ts.factory.createStringLiteral(join("../requests")), undefined),
-        // import all the models by name
-        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
-            ...modalNames.map((modelName) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(modelName))),
-        ])), ts.factory.createStringLiteral(join("../requests/models")), undefined),
     ];
+    if (modelsFile) {
+        // import all the models by name
+        imports.push(ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+            ...modelNames.map((modelName) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(modelName))),
+        ])), ts.factory.createStringLiteral(join("../requests/models")), undefined));
+    }
+    return imports;
 };

package/dist/createSource.mjs

@@ -16,7 +16,6 @@ const createSourceFile = async (outputPath, serviceEndName) => {
     project.addSourceFilesAtPaths(`${sourceFiles}/**/*`);
     const service = await getServices(project);
     const imports = createImports({
-        service,
         serviceEndName,
         project,
     });

package/dist/createUseQuery.mjs

@@ -25,32 +25,44 @@ export const createApiResponseType = ({ className, methodName, }) => {
         responseDataType,
     };
 };
+/**
+ * Replace the import("...") surrounding the type if there is one.
+ * This can happen when the type is imported from another file, but
+ * we are already importing all the types from that file.
+ */
+function getShortType(type) {
+    return type.replaceAll(/import\("[a-zA-Z\/\.-]*"\)\./g, "");
+}
 export function getRequestParamFromMethod(method) {
     if (!method.getParameters().length) {
         return null;
     }
-    // we need to get the properties of the object
-    return ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern(method
-        .getParameters()
-        .map((param) => {
-        const paramNodes = extractPropertiesFromObjectParam(param);
-        return paramNodes.map((refParam) => ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(refParam.name), undefined));
-    })
-        .flat()), undefined, ts.factory.createTypeLiteralNode(method
+    const params = method
         .getParameters()
         .map((param) => {
         const paramNodes = extractPropertiesFromObjectParam(param);
-        return paramNodes.map((refParam) => {
-            return ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(refParam.name), refParam.optional
-                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-                : undefined, 
-            // param.hasQuestionToken() ?? param.getInitializer()?.compilerNode
-            //   ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-            //   : param.getQuestionTokenNode()?.compilerNode,
-            ts.factory.createTypeReferenceNode(refParam.type.getText()));
-        });
+        return paramNodes.map((refParam) => ({
+            name: refParam.name,
+            typeName: getShortType(refParam.type.getText()),
+            optional: refParam.optional,
+        }));
     })
-        .flat()));
+        .flat();
+    const areAllPropertiesOptional = params.every((param) => param.optional);
+    return ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern(params.map((refParam) => ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(refParam.name), undefined))), undefined, ts.factory.createTypeLiteralNode(params.map((refParam) => {
+        return ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(refParam.name), refParam.optional
+            ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+            : undefined, 
+        // param.hasQuestionToken() ?? param.getInitializer()?.compilerNode
+        //   ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+        //   : param.getQuestionTokenNode()?.compilerNode,
+        ts.factory.createTypeReferenceNode(refParam.typeName));
+    })), 
+    // if all params are optional, we create an empty object literal
+    // so the hook can be called without any parameters
+    areAllPropertiesOptional
+        ? ts.factory.createObjectLiteralExpression()
+        : undefined);
 }
 /**
  * Return Type
@@ -107,7 +119,6 @@ function createQueryHook({ queryString, suffix, responseDataType, requestParams,
                 ts.factory.createUnionTypeNode([
                     ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("queryKey")),
                     ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("queryFn")),
-                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("initialData")),
                 ]),
             ])),
         ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier(queryString), [

package/dist/generate.mjs

@@ -22,6 +22,9 @@ export async function generate(options, version) {
         else if (value === "false") {
             acc[typedKey] = false;
         }
+        else {
+            acc[typedKey] = typedValue;
+        }
         return acc;
     }, options);
     const config = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7nohe/openapi-react-query-codegen",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "OpenAPI React Query Codegen",
   "bin": {
     "openapi-rq": "dist/cli.mjs"