Merge pull request #1913 from BogdanMaier/fix/code-genertion-when-optional-field-pagination-is-missing

fix(pagination-parsing): code generation when optional pagination field is missing

Author: mrlubos

.changeset/giant-jeans-study.md

@@ -0,0 +1,5 @@
+---
+"@hey-api/openapi-ts": patch
+---
+
+fix: prevent crash when optional pagination field is missing

packages/openapi-ts/src/ir/__tests__/pagination.test.ts

@@ -1,7 +1,9 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
 import type { Config } from '../../types/config';
+import { operationPagination } from '../operation';
 import { getPaginationKeywordsRegExp } from '../pagination';
+import type { IR } from '../types';
 
 describe('paginationKeywordsRegExp', () => {
   const defaultScenarios: Array<{
@@ -66,9 +68,190 @@ describe('paginationKeywordsRegExp', () => {
       const pagination: Config['input']['pagination'] = {
         keywords: ['customPagination', 'pageSize', 'perPage'],
       };
-
       const paginationRegExp = getPaginationKeywordsRegExp(pagination);
       expect(paginationRegExp.test(value)).toEqual(result);
     },
   );
 });
+
+describe('operationPagination', () => {
+  const queryParam = (
+    name: string,
+    type: IR.SchemaObject['type'] = 'string',
+    pagination = false,
+  ): IR.ParameterObject => ({
+    explode: true,
+    location: 'query',
+    name,
+    schema: { type },
+    style: 'form',
+    ...(pagination ? { pagination: true } : {}),
+  });
+
+  const emptyContext = {} as IR.Context;
+
+  const baseOperationMeta = {
+    method: 'post' as const,
+    path: '/test' as const,
+  };
+
+  const queryScenarios: Array<{
+    hasPagination: boolean;
+    operation: IR.OperationObject;
+  }> = [
+    {
+      hasPagination: true,
+      operation: {
+        ...baseOperationMeta,
+        id: 'op1',
+        method: 'get',
+        parameters: {
+          query: {
+            page: queryParam('page', 'integer', true),
+          },
+        },
+      },
+    },
+    {
+      hasPagination: false,
+      operation: {
+        ...baseOperationMeta,
+        id: 'op2',
+        method: 'get',
+        parameters: {
+          query: {
+            sort: queryParam('sort', 'string'),
+          },
+        },
+      },
+    },
+  ];
+
+  it.each(queryScenarios)(
+    'query params for $operation.id → $hasPagination',
+    ({
+      hasPagination,
+      operation,
+    }: {
+      hasPagination: boolean;
+      operation: IR.OperationObject;
+    }) => {
+      const result = operationPagination({ context: emptyContext, operation });
+      expect(Boolean(result)).toEqual(hasPagination);
+    },
+  );
+
+  it('body.pagination === true returns entire body', () => {
+    const operation: IR.OperationObject = {
+      ...baseOperationMeta,
+      body: {
+        mediaType: 'application/json',
+        pagination: true,
+        schema: {
+          properties: {
+            page: { type: 'integer' },
+          },
+          type: 'object',
+        },
+      },
+      id: 'bodyTrue',
+    };
+
+    const result = operationPagination({ context: emptyContext, operation });
+
+    expect(result?.in).toEqual('body');
+    expect(result?.name).toEqual('body');
+    expect(result?.schema?.type).toEqual('object');
+  });
+
+  it('body.pagination = "pagination" returns the matching property', () => {
+    const operation: IR.OperationObject = {
+      ...baseOperationMeta,
+      body: {
+        mediaType: 'application/json',
+        pagination: 'pagination',
+        schema: {
+          properties: {
+            pagination: {
+              properties: {
+                page: { type: 'integer' },
+              },
+              type: 'object',
+            },
+          },
+          type: 'object',
+        },
+      },
+      id: 'bodyField',
+    };
+
+    const result = operationPagination({ context: emptyContext, operation });
+
+    expect(result?.in).toEqual('body');
+    expect(result?.name).toEqual('pagination');
+    expect(result?.schema?.type).toEqual('object');
+  });
+
+  it('resolves $ref and uses the resolved pagination property', () => {
+    const context: IR.Context = {
+      resolveIrRef: vi.fn().mockReturnValue({
+        properties: {
+          pagination: {
+            properties: {
+              page: { type: 'integer' },
+            },
+            type: 'object',
+          },
+        },
+        type: 'object',
+      }),
+    } as unknown as IR.Context;
+
+    const operation: IR.OperationObject = {
+      ...baseOperationMeta,
+      body: {
+        mediaType: 'application/json',
+        pagination: 'pagination',
+        schema: { $ref: '#/components/schemas/PaginationBody' },
+      },
+      id: 'refPagination',
+    };
+
+    const result = operationPagination({ context, operation });
+
+    expect(context.resolveIrRef).toHaveBeenCalledWith(
+      '#/components/schemas/PaginationBody',
+    );
+    expect(result?.in).toEqual('body');
+    expect(result?.name).toEqual('pagination');
+    expect(result?.schema?.type).toEqual('object');
+  });
+
+  it('falls back to query when pagination key not found in body', () => {
+    const operation: IR.OperationObject = {
+      ...baseOperationMeta,
+      body: {
+        mediaType: 'application/json',
+        pagination: 'pagination',
+        schema: {
+          properties: {
+            notPagination: { type: 'string' },
+          },
+          type: 'object',
+        },
+      },
+      id: 'fallback',
+      parameters: {
+        query: {
+          cursor: queryParam('cursor', 'string', true),
+        },
+      },
+    };
+
+    const result = operationPagination({ context: emptyContext, operation });
+
+    expect(result?.in).toEqual('query');
+    expect(result?.name).toEqual('cursor');
+    expect(result?.schema?.type).toEqual('string');
+  });
+});

packages/openapi-ts/src/ir/operation.ts

@@ -28,29 +28,38 @@ export const operationPagination = ({
   context: IR.Context;
   operation: IR.OperationObject;
 }): Pagination | undefined => {
-  if (operation.body?.pagination) {
-    if (typeof operation.body.pagination === 'boolean') {
-      return {
-        in: 'body',
-        name: 'body',
-        schema: operation.body.schema,
-      };
-    }
+  const body = operation.body;
+
+  if (!body || !body.pagination) {
+    return parameterWithPagination(operation.parameters);
+  }
 
-    const schema = operation.body.schema.$ref
-      ? context.resolveIrRef<IR.RequestBodyObject | IR.SchemaObject>(
-          operation.body.schema.$ref,
-        )
-      : operation.body.schema;
-    const finalSchema = 'schema' in schema ? schema.schema : schema;
+  if (body.pagination === true) {
     return {
       in: 'body',
-      name: operation.body.pagination,
-      schema: finalSchema.properties![operation.body.pagination]!,
+      name: 'body',
+      schema: body.schema,
     };
   }
 
-  return parameterWithPagination(operation.parameters);
+  const schema = body.schema;
+  const resolvedSchema = schema.$ref
+    ? context.resolveIrRef<IR.RequestBodyObject | IR.SchemaObject>(schema.$ref)
+    : schema;
+
+  const finalSchema =
+    'schema' in resolvedSchema ? resolvedSchema.schema : resolvedSchema;
+  const paginationProp = finalSchema?.properties?.[body.pagination];
+
+  if (!paginationProp) {
+    return parameterWithPagination(operation.parameters);
+  }
+
+  return {
+    in: 'body',
+    name: body.pagination,
+    schema: paginationProp,
+  };
 };
 
 type StatusGroup = '1XX' | '2XX' | '3XX' | '4XX' | '5XX' | 'default';