refactor: replace type assertions with type guards and narrowing

- service.mts: remove all `as` casts by using ts.isArrowFunction,
  ts.isReturnStatement, ts.isCallExpression type guards for proper narrowing
- createExports.mts: use reduce generic, ts.isTypeLiteralNode,
  ts.isPropertySignature type guards, and type predicate filter
- createUseQuery.mts: add comments explaining unavoidable assertions
  on factory-created nodes

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: TakehiroTada

src/createExports.mts

@@ -24,13 +24,13 @@ export const createExports = ({
   initialPageParam: string;
 }) => {
   const { methods } = service;
-  const methodDataNames = methods.reduce(
+  const methodDataNames = methods.reduce<Record<string, string>>(
     (acc, data) => {
       const methodName = data.method.getName();
       acc[`${capitalizeFirstLetter(methodName)}Data`] = methodName;
       return acc;
     },
-    {} as { [key: string]: string },
+    {},
   );
   const modelsFile = project
     .getSourceFiles?.()
@@ -46,14 +46,13 @@ export const createExports = ({
     if (ts.isTypeAliasDeclaration(node) && methodDataNames[key] !== undefined) {
       // get the type alias declaration
       const typeAliasDeclaration = node.type;
-      if (typeAliasDeclaration.kind === ts.SyntaxKind.TypeLiteral) {
-        const query = (typeAliasDeclaration as ts.TypeLiteralNode).members.find(
-          (m) =>
-            m.kind === ts.SyntaxKind.PropertySignature &&
-            m.name?.getText() === "query",
+      if (ts.isTypeLiteralNode(typeAliasDeclaration)) {
+        const query = typeAliasDeclaration.members.find(
+          (m): m is ts.PropertySignature =>
+            ts.isPropertySignature(m) && m.name?.getText() === "query",
         );
         if (query) {
-          const queryType = (query as ts.PropertySignature).type;
+          const queryType = query.type;
           const members =
             queryType && ts.isTypeLiteralNode(queryType)
               ? queryType.members
@@ -148,7 +147,7 @@ export const createExports = ({
 
   const infiniteQueriesExports = allQueries
     .flatMap(({ infiniteQueryHook }) => [infiniteQueryHook])
-    .filter(Boolean) as ts.VariableStatement[];
+    .filter((x): x is ts.VariableStatement => x != null);
 
   const suspenseQueries = allQueries.flatMap(({ suspenseQueryHook }) => [
     suspenseQueryHook,

src/createUseQuery.mts

@@ -225,6 +225,9 @@ function createQueryHook({
   const isInfiniteQuery = queryString === "useInfiniteQuery";
   const isSuspenseQuery = queryString === "useSuspenseQuery";
 
+  // ts.TypeParameterDeclaration.default is ts.TypeNode | undefined.
+  // We know it's a TypeReferenceNode with an Identifier typeName because we created it
+  // via ts.factory in createApiResponseType, but TypeScript cannot infer the specific subtype.
   const responseDataTypeRef = responseDataType.default as ts.TypeReferenceNode;
   const responseDataTypeIdentifier =
     responseDataTypeRef.typeName as ts.Identifier;

src/service.mts

@@ -32,9 +32,7 @@ export function getMethodsFromService(node: SourceFile): FunctionDescription[] {
     const declarations = statement.getDeclarations();
     return declarations.some((decl) => {
       const initializer = decl.getInitializer();
-      return (
-        initializer && ts.isArrowFunction(initializer.compilerNode as ts.Node)
-      );
+      return initializer && ts.isArrowFunction(initializer.compilerNode);
     });
   });
 
@@ -45,42 +43,39 @@ export function getMethodsFromService(node: SourceFile): FunctionDescription[] {
       if (!initializer) {
         throw new Error("Initializer not found");
       }
-      const arrowFunction = initializer.compilerNode as ts.ArrowFunction;
-      if (!ts.isArrowFunction(arrowFunction)) {
+      const compilerNode = initializer.compilerNode;
+      if (!ts.isArrowFunction(compilerNode)) {
         throw new Error("Arrow function not found");
       }
-      const arrowBody = arrowFunction.body;
+      const arrowBody = compilerNode.body;
 
       // Find the call expression - either from block's return statement or direct expression
-      let callExpression: ts.CallExpression;
+      let callExpression: ts.Expression;
       let methodBlockNode: ts.Block | undefined;
 
       if (ts.isBlock(arrowBody)) {
         // Old style: arrow function with block body
         methodBlockNode = arrowBody;
-        const foundReturnStatement = arrowBody.statements.find(
-          (s) => s.kind === ts.SyntaxKind.ReturnStatement,
-        );
-        if (!foundReturnStatement) {
+        const returnStatement = arrowBody.statements.find(ts.isReturnStatement);
+        if (!returnStatement) {
           throw new Error("Return statement not found");
         }
-        const returnStatement = foundReturnStatement as ts.ReturnStatement;
         if (!returnStatement.expression) {
           throw new Error("Call expression not found");
         }
-        callExpression = returnStatement.expression as ts.CallExpression;
+        callExpression = returnStatement.expression;
       } else {
         // New style: arrow function with expression body (no block)
         // The body is a call expression like: (options?.client ?? client).post<...>({...})
-        callExpression = arrowBody as ts.CallExpression;
+        callExpression = arrowBody;
       }
 
       // Navigate to find the HTTP method name (get, post, put, delete, etc.)
       let httpMethodName: string | undefined;
       if (ts.isCallExpression(callExpression)) {
         const expr = callExpression.expression;
         if (ts.isPropertyAccessExpression(expr)) {
-          httpMethodName = (expr.name as ts.Identifier).text;
+          httpMethodName = expr.name.text;
         }
       }