fixes type errors that started to complain for some reason

snebjorn · snebjorn · commit c50dde472fc9 · 2025-11-11T23:57:40.000+01:00
diff --git a/packages/core/src/generators/mutator-info.ts b/packages/core/src/generators/mutator-info.ts
@@ -2,6 +2,7 @@ import path from 'node:path';
 
 import { type ecmaVersion, Parser, type Program } from 'acorn';
 import { build, type BuildOptions } from 'esbuild';
+import { isArray } from 'remeda';
 
 import type {
   GeneratorMutatorParsingInfo,
@@ -101,7 +102,9 @@ function parseFunction(
 ): GeneratorMutatorParsingInfo | undefined {
   const node = ast.body.find((childNode) => {
     if (childNode.type === 'VariableDeclaration') {
-      return childNode.declarations.find((d) => d.id.name === funcName);
+      return childNode.declarations.find(
+        (d) => d.id.type === 'Identifier' && d.id.name === funcName,
+      );
     }
     if (
       childNode.type === 'FunctionDeclaration' &&
@@ -121,7 +124,7 @@ function parseFunction(
     );
 
     // If the function directly returns an arrow function
-    if (returnStatement?.argument?.params) {
+    if (returnStatement?.argument && 'params' in returnStatement.argument) {
       return {
         numberOfParams: node.params.length,
         returnNumberOfParams: returnStatement.argument.params.length,
@@ -141,42 +144,59 @@ function parseFunction(
     };
   }
 
-  const declaration = node.declarations.find((d) => d.id.name === funcName);
+  const declaration =
+    'declarations' in node
+      ? node.declarations.find(
+          (d) => d.id.type === 'Identifier' && d.id.name === funcName,
+        )
+      : undefined;
 
-  if (declaration.init.name) {
-    return parseFunction(ast, declaration.init.name);
-  }
+  if (declaration?.init) {
+    if ('name' in declaration.init) {
+      return parseFunction(ast, declaration.init.name);
+    }
 
-  if (declaration.init.body.type === 'ArrowFunctionExpression') {
-    return {
-      numberOfParams: declaration.init.params.length,
-      returnNumberOfParams: declaration.init.body.params.length,
-    };
-  }
+    if (
+      'body' in declaration.init &&
+      'params' in declaration.init &&
+      declaration.init.body.type === 'ArrowFunctionExpression'
+    ) {
+      return {
+        numberOfParams: declaration.init.params.length,
+        returnNumberOfParams: declaration.init.body.params.length,
+      };
+    }
 
-  const returnStatement = declaration.init.body?.body?.find(
-    (b: any) => b.type === 'ReturnStatement',
-  );
+    const returnStatement =
+      'body' in declaration.init &&
+      'body' in declaration.init.body &&
+      isArray(declaration.init.body.body)
+        ? declaration.init.body.body.find((b) => b.type === 'ReturnStatement')
+        : undefined;
 
-  if (returnStatement?.argument?.params) {
-    return {
-      numberOfParams: declaration.init.params.length,
-      returnNumberOfParams: returnStatement.argument.params.length,
-    };
-  } else if (
-    returnStatement?.argument?.type === 'CallExpression' &&
-    returnStatement.argument.arguments?.[0]?.type === 'ArrowFunctionExpression'
-  ) {
-    const arrowFn = returnStatement.argument.arguments[0];
-    return {
-      numberOfParams: declaration.init.params.length,
-      returnNumberOfParams: arrowFn.params.length,
-    };
-  }
+    if ('params' in declaration.init) {
+      if (returnStatement?.argument && 'params' in returnStatement.argument) {
+        return {
+          numberOfParams: declaration.init.params.length,
+          returnNumberOfParams: returnStatement.argument.params.length,
+        };
+      } else if (
+        returnStatement?.argument?.type === 'CallExpression' &&
+        returnStatement.argument.arguments[0]?.type ===
+          'ArrowFunctionExpression'
+      ) {
+        const arrowFn = returnStatement.argument.arguments[0];
+        return {
+          numberOfParams: declaration.init.params.length,
+          returnNumberOfParams: arrowFn.params.length,
+        };
+      }
 
-  return {
-    numberOfParams: declaration.init.params.length,
-  };
+      return {
+        numberOfParams: declaration.init.params.length,
+      };
+    }
+  }
 }
 
 function getEcmaVersion(target?: TsConfigTarget): ecmaVersion | undefined {
diff --git a/packages/core/src/generators/verbs-options.ts b/packages/core/src/generators/verbs-options.ts
@@ -66,12 +66,12 @@ const generateVerbOptions = async ({
     summary,
   } = operation;
   const operationId = getOperationId(operation, route, verb);
-  const overrideOperation = output.override.operations[operation.operationId!];
+  const overrideOperation = output.override.operations[operation.operationId!]!;
   const overrideTag = Object.entries(
     output.override.tags,
   ).reduce<NormalizedOperationOptions>(
     (acc, [tag, options]) =>
-      tags.includes(tag) ? mergeDeep(acc, options) : acc,
+      tags.includes(tag) && options ? mergeDeep(acc, options) : acc,
     {},
   );
 
diff --git a/packages/core/src/writers/single-mode.ts b/packages/core/src/writers/single-mode.ts
@@ -78,7 +78,7 @@ export const writeSingleMode = async ({
       isAllowSyntheticDefaultImports,
       hasGlobalMutator: !!output.override.mutator,
       hasTagsMutator: Object.values(output.override.tags).some(
-        (tag) => !!tag.mutator,
+        (tag) => !!tag?.mutator,
       ),
       hasParamsSerializerOptions: !!output.override.paramsSerializerOptions,
       packageJson: output.packageJson,
diff --git a/packages/core/src/writers/split-mode.ts b/packages/core/src/writers/split-mode.ts
@@ -76,7 +76,7 @@ export const writeSplitMode = async ({
       isAllowSyntheticDefaultImports,
       hasGlobalMutator: !!output.override.mutator,
       hasTagsMutator: Object.values(output.override.tags).some(
-        (tag) => !!tag.mutator,
+        (tag) => !!tag?.mutator,
       ),
       hasParamsSerializerOptions: !!output.override.paramsSerializerOptions,
       packageJson: output.packageJson,
diff --git a/packages/core/src/writers/split-tags-mode.ts b/packages/core/src/writers/split-tags-mode.ts
@@ -90,7 +90,7 @@ export const writeSplitTagsMode = async ({
           isAllowSyntheticDefaultImports,
           hasGlobalMutator: !!output.override.mutator,
           hasTagsMutator: Object.values(output.override.tags).some(
-            (tag) => !!tag.mutator,
+            (tag) => !!tag?.mutator,
           ),
           hasParamsSerializerOptions: !!output.override.paramsSerializerOptions,
           packageJson: output.packageJson,
diff --git a/packages/core/src/writers/tags-mode.ts b/packages/core/src/writers/tags-mode.ts
@@ -78,7 +78,7 @@ export const writeTagsMode = async ({
           isAllowSyntheticDefaultImports,
           hasGlobalMutator: !!output.override.mutator,
           hasTagsMutator: Object.values(output.override.tags).some(
-            (tag) => !!tag.mutator,
+            (tag) => !!tag?.mutator,
           ),
           hasParamsSerializerOptions: !!output.override.paramsSerializerOptions,
           packageJson: output.packageJson,
diff --git a/packages/zod/src/index.ts b/packages/zod/src/index.ts
@@ -22,18 +22,14 @@ import {
   type ZodCoerceType,
 } from '@orval/core';
 import {
-  isSchemaObject,
   type ParameterObject,
   type PathItemObject,
   type ReferenceObject,
   type RequestBodyObject,
   type ResponseObject,
   type SchemaObject,
 } from 'openapi3-ts/oas30';
-import {
-  isSchemaObject as isSchemaObject31,
-  type SchemaObject as SchemaObject31,
-} from 'openapi3-ts/oas31';
+import { type SchemaObject as SchemaObject31 } from 'openapi3-ts/oas31';
 import { unique } from 'remeda';
 
 import {
@@ -805,8 +801,10 @@ ${Object.entries(mergedProperties)
     }
     if (fn === 'oneOf' || fn === 'anyOf') {
       // Can't use zod.union() with a single item
-      if (args.length === 1) {
-        return args[0].functions.map((prop) => parseProperty(prop)).join('');
+      if (args?.length === 1) {
+        return args[0].functions
+          .map((prop: any) => parseProperty(prop))
+          .join('');
       }
 
       const union = args.map(
@@ -829,7 +827,9 @@ ${Object.entries(mergedProperties)
     }
 
     if (fn === 'additionalProperties') {
-      const value = args.functions.map((prop) => parseProperty(prop)).join('');
+      const value = args.functions
+        .map((prop: any) => parseProperty(prop))
+        .join('');
       const valueWithZod = `${value.startsWith('.') ? 'zod' : ''}${value}`;
       consts += args.consts;
       return `zod.record(zod.string(), ${valueWithZod})`;
@@ -851,7 +851,9 @@ ${Object.entries(args)
 })`;
     }
     if (fn === 'array') {
-      const value = args.functions.map((prop) => parseProperty(prop)).join('');
+      const value = args.functions
+        .map((prop: any) => parseProperty(prop))
+        .join('');
       if (typeof args.consts === 'string') {
         consts += args.consts;
       } else if (Array.isArray(args.consts)) {
