fix: infinite loop in transforms

.changeset/quick-trees-laugh.md

@@ -0,0 +1,5 @@
+---
+'@hey-api/openapi-ts': patch
+---
+
+fix: handle void responses in transformers

packages/openapi-ts/src/compiler/convert.ts

@@ -0,0 +1,10 @@
+import ts from 'typescript';
+
+export const convertExpressionToStatement = ({
+  expression,
+}: {
+  expression: ts.Expression;
+}) => {
+  const statement = ts.factory.createExpressionStatement(expression);
+  return statement;
+};

packages/openapi-ts/src/compiler/function.ts

@@ -0,0 +1,19 @@
+import ts from 'typescript';
+
+export const createCallExpression = ({
+  parameters,
+  functionName,
+}: {
+  parameters: Array<string>;
+  functionName: string;
+}) => {
+  const functionIdentifier = ts.factory.createIdentifier(functionName);
+
+  const callExpression = ts.factory.createCallExpression(
+    functionIdentifier,
+    undefined,
+    parameters.map((parameter) => ts.factory.createIdentifier(parameter)),
+  );
+
+  return callExpression;
+};

packages/openapi-ts/src/compiler/index.ts

@@ -4,6 +4,8 @@
 import ts from 'typescript';
 
 import * as classes from './classes';
+import * as convert from './convert';
+import * as functions from './function';
 import * as module from './module';
 import * as _return from './return';
 import * as transform from './transform';
@@ -78,6 +80,13 @@
     rmSync(this._path, options);
   }
 
+  /**
+   * Removes last node form the stack. Works as undo.
+   */
+  public removeNode() {
+    this._items = this._items.slice(0, this._items.length - 1);
+  }
+
   private _setName(fileName: string) {
     if (fileName.includes('index')) {
       return fileName;
@@ -124,16 +133,28 @@
     create: classes.createClassDeclaration,
     method: classes.createMethodDeclaration,
   },
+  convert: {
+    expressionToStatement: convert.convertExpressionToStatement,
+  },
   export: {
     all: module.createExportAllDeclaration,
     const: module.createExportConstVariable,
     named: module.createNamedExportDeclarations,
   },
+  function: {
+    call: functions.createCallExpression,
+  },
   import: {
     named: module.createNamedImportDeclarations,
   },
+  logic: {
+    access: transform.createAccessExpression,
+    if: transform.createIfStatement,
+    safeAccess: transform.createSafeAccessExpression,
+  },
   return: {
     functionCall: _return.createReturnFunctionCall,
+    statement: _return.createReturnStatement,
   },
   transform: {
     alias: transform.createAlias,
@@ -143,7 +164,6 @@
     newDate: transform.createDateTransformerExpression,
     responseArrayTransform: transform.createResponseArrayTransform,
     transformItem: transform.createFunctionTransformMutation,
-    transformMutationFunction: transform.createTransformMutationFunction,
   },
   typedef: {
     alias: typedef.createTypeAliasDeclaration,

packages/openapi-ts/src/compiler/module.ts

@@ -69,11 +69,13 @@ export const createExportConstVariable = ({
   constAssertion = false,
   expression,
   name,
+  typeName,
 }: {
   comment?: Comments;
   constAssertion?: boolean;
   expression: ts.Expression;
   name: string;
+  typeName?: string;
 }): ts.VariableStatement => {
   const initializer = constAssertion
     ? ts.factory.createAsExpression(
@@ -84,7 +86,7 @@ export const createExportConstVariable = ({
   const declaration = ts.factory.createVariableDeclaration(
     ts.factory.createIdentifier(name),
     undefined,
-    undefined,
+    typeName ? ts.factory.createTypeReferenceNode(typeName) : undefined,
     initializer,
   );
   const statement = ts.factory.createVariableStatement(

packages/openapi-ts/src/compiler/return.ts

@@ -28,8 +28,12 @@
       )
       .filter(isType<ts.Identifier | ts.Expression>),
   );
-
-  const statement = ts.factory.createReturnStatement(expression);
-
+  const statement = createReturnStatement({ expression });
   return statement;
 };
+
+export const createReturnStatement = ({
+  expression,
+}: {
+  expression?: ts.Expression;
+}) => ts.factory.createReturnStatement(expression);