@sdk-it/spec 0.31.0 → 0.31.2

package/dist/lib/pagination/pagination.test.js

@@ -1,379 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import {
-  CURSOR_LIMIT_REGEXES,
-  CURSOR_REGEXES,
-  GENERIC_LIMIT_PARAM_REGEXES,
-  OFFSET_PARAM_REGEXES,
-  PAGE_NUMBER_REGEXES,
-  PAGE_SIZE_REGEXES,
-  guessPagination
-} from "./guess-pagination.ts";
-function createOperation(params) {
-  return {
-    "x-fn-name": "testFunction",
-    tags: ["test"],
-    operationId: "testOperation",
-    parameters: params,
-    requestBody: { content: {} },
-    responses: {}
-  };
-}
-function qParam(name) {
-  return {
-    name,
-    in: "query",
-    required: false,
-    schema: {
-      type: "string"
-    }
-  };
-}
-function hParam(name) {
-  return {
-    name,
-    in: "header",
-    required: false,
-    schema: {
-      type: "string"
-    }
-  };
-}
-function pParam(name) {
-  return {
-    name,
-    in: "path",
-    required: false,
-    schema: {
-      type: "string"
-    }
-  };
-}
-function getExpectedKeyword(paramName, regexArray) {
-  for (const regex of regexArray) {
-    const match = paramName.match(regex);
-    if (match) {
-      return match[0];
-    }
-  }
-  return paramName;
-}
-describe("guessPagination()", () => {
-  describe("No Pagination Detected", () => {
-    test('should return "none" for an operation with an empty parameters array', () => {
-      const op = createOperation([]);
-      assert.deepStrictEqual(guessPagination(op), { type: "none" });
-    });
-    test('should return "none" for an operation with undefined parameters', () => {
-      const op = createOperation(void 0);
-      assert.deepStrictEqual(guessPagination(op), { type: "none" });
-    });
-    test('should return "none" for non-pagination query parameters', () => {
-      const op = createOperation([qParam("search"), qParam("filterBy")]);
-      assert.deepStrictEqual(guessPagination(op), { type: "none" });
-    });
-    test('should return "none" if relevant parameters are not in "query"', () => {
-      const op = createOperation([hParam("offset"), hParam("limit")]);
-      assert.deepStrictEqual(guessPagination(op), { type: "none" });
-    });
-    test('should return "none" if only one part of a pair is present (e.g., only offset)', () => {
-      assert.deepStrictEqual(
-        guessPagination(createOperation([qParam("offset")])),
-        { type: "none" },
-        "Only offset"
-      );
-      assert.deepStrictEqual(
-        guessPagination(createOperation([qParam("page")])),
-        { type: "none" },
-        "Only page"
-      );
-      assert.deepStrictEqual(
-        guessPagination(createOperation([qParam("cursor")])),
-        { type: "none" },
-        "Only cursor"
-      );
-      assert.deepStrictEqual(
-        guessPagination(createOperation([qParam("limit")])),
-        { type: "none" },
-        "Only limit"
-      );
-    });
-    test('should return "none" for mixed non-query and insufficient query params', () => {
-      const op = createOperation([
-        pParam("userId"),
-        qParam("offset"),
-        hParam("X-Request-ID")
-      ]);
-      assert.deepStrictEqual(guessPagination(op), { type: "none" });
-    });
-  });
-  describe("Offset Pagination Detection", () => {
-    const testOffsetKeywords = [
-      "offset",
-      "skip",
-      "start",
-      "start_index",
-      "starting_at",
-      "from",
-      "Offset",
-      "SKIP"
-    ];
-    const testLimitKeywords = [
-      "limit",
-      "count",
-      "size",
-      "page_size",
-      "pageSize",
-      "max_results",
-      "take",
-      "Limit",
-      "COUNT"
-    ];
-    for (const offsetKey of testOffsetKeywords) {
-      for (const limitKey of testLimitKeywords) {
-        if (offsetKey.toLowerCase() === limitKey.toLowerCase()) continue;
-        test(`should detect offset with "${offsetKey}" and "${limitKey}"`, () => {
-          const op = createOperation([qParam(offsetKey), qParam(limitKey)]);
-          const result = guessPagination(op);
-          assert.strictEqual(
-            result.type,
-            "offset",
-            `Failed for ${offsetKey}, ${limitKey}`
-          );
-          assert.strictEqual(result.offsetParamName, offsetKey);
-          assert.strictEqual(
-            result.offsetKeyword,
-            getExpectedKeyword(offsetKey, OFFSET_PARAM_REGEXES)
-          );
-          assert.strictEqual(result.limitParamName, limitKey);
-          assert.strictEqual(
-            result.limitKeyword,
-            getExpectedKeyword(limitKey, GENERIC_LIMIT_PARAM_REGEXES)
-          );
-        });
-      }
-    }
-    test("should not detect offset if one param is not in query", () => {
-      const op = createOperation([hParam("offset"), qParam("limit")]);
-      assert.deepStrictEqual(guessPagination(op), { type: "none" });
-    });
-    test("should not detect with two offset-like params and no limit", () => {
-      const op = createOperation([qParam("offset"), qParam("skip")]);
-      assert.deepStrictEqual(guessPagination(op), { type: "none" });
-    });
-    test("should correctly handle params in different order", () => {
-      const op = createOperation([qParam("limit"), qParam("offset")]);
-      const result = guessPagination(op);
-      assert.strictEqual(result.type, "offset");
-      assert.strictEqual(result.offsetParamName, "offset");
-      assert.strictEqual(result.limitParamName, "limit");
-    });
-    test("should handle extra non-pagination params", () => {
-      const op = createOperation([
-        qParam("filter"),
-        qParam("offset"),
-        qParam("sort"),
-        qParam("limit")
-      ]);
-      const result = guessPagination(op);
-      assert.strictEqual(result.type, "offset");
-      assert.strictEqual(result.offsetParamName, "offset");
-      assert.strictEqual(result.limitParamName, "limit");
-    });
-  });
-  describe("Page Pagination Detection", () => {
-    const testPageNumKeywords = [
-      "page",
-      "p",
-      "page_number",
-      "pageNum",
-      "page_idx",
-      "Page",
-      "P"
-    ];
-    const testPageSizeKeywords = [
-      "page_size",
-      "pageSize",
-      "size",
-      "limit",
-      "count",
-      "per_page",
-      "per-page",
-      "num_items",
-      "Size",
-      "LIMIT"
-    ];
-    for (const pageKey of testPageNumKeywords) {
-      for (const sizeKey of testPageSizeKeywords) {
-        if (pageKey.toLowerCase() === sizeKey.toLowerCase()) continue;
-        test(`should detect page with "${pageKey}" and "${sizeKey}"`, () => {
-          const op = createOperation([qParam(pageKey), qParam(sizeKey)]);
-          const result = guessPagination(op);
-          assert.strictEqual(
-            result.type,
-            "page",
-            `Failed for ${pageKey}, ${sizeKey}`
-          );
-          assert.strictEqual(result.pageNumberParamName, pageKey);
-          assert.strictEqual(
-            result.pageNumberKeyword,
-            getExpectedKeyword(pageKey, PAGE_NUMBER_REGEXES)
-          );
-          assert.strictEqual(result.pageSizeParamName, sizeKey);
-          assert.strictEqual(
-            result.pageSizeKeyword,
-            getExpectedKeyword(sizeKey, PAGE_SIZE_REGEXES)
-          );
-        });
-      }
-    }
-    test("should not detect page if one param is not in query", () => {
-      const op = createOperation([hParam("page"), qParam("size")]);
-      assert.deepStrictEqual(guessPagination(op), { type: "none" });
-    });
-    test("should not detect with two page-number-like params and no size", () => {
-      const op = createOperation([qParam("page"), qParam("page_number")]);
-      assert.deepStrictEqual(guessPagination(op), { type: "none" });
-    });
-  });
-  describe("Cursor Pagination Detection", () => {
-    const testCursorKeywords = [
-      "cursor",
-      "after",
-      "before_cursor",
-      "next_page_token",
-      "pageToken",
-      "continuation_token",
-      "Cursor",
-      "AFTER"
-    ];
-    const testCursorLimitKeywords = [
-      "limit",
-      "count",
-      "size",
-      "first",
-      "last",
-      "page_size",
-      "num_items",
-      "take",
-      "First",
-      "LAST"
-    ];
-    for (const cursorKey of testCursorKeywords) {
-      for (const limitKey of testCursorLimitKeywords) {
-        if (cursorKey.toLowerCase() === limitKey.toLowerCase()) continue;
-        test(`should detect cursor with "${cursorKey}" and "${limitKey}"`, () => {
-          const op = createOperation([qParam(cursorKey), qParam(limitKey)]);
-          const result = guessPagination(op);
-          assert.strictEqual(
-            result.type,
-            "cursor",
-            `Failed for ${cursorKey}, ${limitKey}`
-          );
-          assert.strictEqual(result.cursorParamName, cursorKey);
-          assert.strictEqual(
-            result.cursorKeyword,
-            getExpectedKeyword(cursorKey, CURSOR_REGEXES)
-          );
-          assert.strictEqual(result.limitParamName, limitKey);
-          assert.strictEqual(
-            result.limitKeyword,
-            getExpectedKeyword(limitKey, CURSOR_LIMIT_REGEXES)
-          );
-        });
-      }
-    }
-    test("should not detect cursor if one param is not in query", () => {
-      const op = createOperation([hParam("cursor"), qParam("first")]);
-      assert.deepStrictEqual(guessPagination(op), { type: "none" });
-    });
-    test("should not detect with two cursor-like params and no limit", () => {
-      const op = createOperation([qParam("cursor"), qParam("after")]);
-      assert.deepStrictEqual(guessPagination(op), { type: "none" });
-    });
-  });
-  describe("Pagination Type Precedence", () => {
-    test('Offset should take precedence over Page (e.g., "skip", "limit", "page")', () => {
-      const op = createOperation([
-        qParam("skip"),
-        qParam("limit"),
-        qParam("page")
-      ]);
-      const result = guessPagination(op);
-      assert.strictEqual(result.type, "offset");
-      if (result.type === "offset") {
-        assert.strictEqual(result.offsetParamName, "skip");
-        assert.strictEqual(result.limitParamName, "limit");
-      }
-    });
-    test('Offset should take precedence over Cursor (e.g., "offset", "count", "after_token")', () => {
-      const op = createOperation([
-        qParam("offset"),
-        qParam("count"),
-        qParam("after_token")
-      ]);
-      const result = guessPagination(op);
-      assert.strictEqual(result.type, "offset");
-      if (result.type === "offset") {
-        assert.strictEqual(result.offsetParamName, "offset");
-        assert.strictEqual(result.limitParamName, "count");
-      }
-    });
-    test('Page should take precedence over Cursor (e.g., "page", "size", "next_cursor")', () => {
-      const op = createOperation([
-        qParam("page"),
-        qParam("size"),
-        qParam("next_cursor")
-      ]);
-      const result = guessPagination(op);
-      assert.strictEqual(result.type, "page");
-      if (result.type === "page") {
-        assert.strictEqual(result.pageNumberParamName, "page");
-        assert.strictEqual(result.pageSizeParamName, "size");
-      }
-    });
-    test('Params like "page" and "limit" should resolve to Page pagination', () => {
-      const op = createOperation([qParam("page"), qParam("limit")]);
-      const result = guessPagination(op);
-      assert.strictEqual(result.type, "page");
-      if (result.type === "page") {
-        assert.strictEqual(result.pageNumberParamName, "page");
-        assert.strictEqual(result.pageSizeParamName, "limit");
-      }
-    });
-  });
-  describe("Regex Specificity and Word Boundaries", () => {
-    test('should not match "custom_offset" as "offset" due to word boundary (with real implementation)', () => {
-      const op = createOperation([
-        qParam("custom_offset_param"),
-        qParam("limit")
-      ]);
-      assert.ok(
-        true,
-        "Test needs real implementation for accurate regex boundary check"
-      );
-    });
-    test('should match "offset_custom" for "offset" keyword (with real implementation)', () => {
-      const op = createOperation([qParam("offset_custom"), qParam("limit")]);
-      assert.ok(
-        true,
-        "Test needs real implementation for accurate keyword extraction"
-      );
-    });
-    test('should match "page" exactly for page number, not "my_page_details" (with real implementation)', () => {
-      const op = createOperation([qParam("my_page_details"), qParam("size")]);
-      assert.ok(
-        true,
-        "Test needs real implementation for exact regex matching"
-      );
-    });
-    test('should match "p" exactly for page number (with real implementation)', () => {
-      const op = createOperation([qParam("p"), qParam("size")]);
-      assert.ok(
-        true,
-        "Test needs real implementation for exact regex matching"
-      );
-    });
-  });
-});
-//# sourceMappingURL=pagination.test.js.map

package/dist/lib/pagination/pagination.test.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/pagination/pagination.test.ts"],
-  "sourcesContent": ["import assert from 'node:assert/strict';\nimport { describe, test } from 'node:test';\nimport type { ParameterObject } from 'openapi3-ts/oas31';\n\nimport type { TunedOperationObject } from '../types.ts';\nimport {\n  CURSOR_LIMIT_REGEXES,\n  CURSOR_REGEXES,\n  GENERIC_LIMIT_PARAM_REGEXES,\n  OFFSET_PARAM_REGEXES,\n  PAGE_NUMBER_REGEXES,\n  PAGE_SIZE_REGEXES,\n  guessPagination,\n} from './guess-pagination.ts';\n\nfunction createOperation(params: ParameterObject[]): TunedOperationObject {\n  return {\n    'x-fn-name': 'testFunction',\n    tags: ['test'],\n    operationId: 'testOperation',\n    parameters: params,\n    requestBody: { content: {} },\n    responses: {},\n  };\n}\n\nfunction qParam(name: string): ParameterObject {\n  return {\n    name,\n    in: 'query',\n    required: false,\n    schema: {\n      type: 'string',\n    },\n  };\n}\n\nfunction hParam(name: string): ParameterObject {\n  return {\n    name,\n    in: 'header',\n    required: false,\n    schema: {\n      type: 'string',\n    },\n  };\n}\nfunction pParam(name: string): ParameterObject {\n  return {\n    name,\n    in: 'path',\n    required: false,\n    schema: {\n      type: 'string',\n    },\n  };\n}\nfunction getExpectedKeyword(paramName: string, regexArray: RegExp[]): string {\n  for (const regex of regexArray) {\n    const match = paramName.match(regex);\n    if (match) {\n      return match[0];\n    }\n  }\n  // This might return undefined if the paramName is not expected to match any regex in the array,\n  // which is fine for negative test cases or if the mock doesn't perfectly align.\n  // For positive cases, ensure your actual implementation and regexes would provide a match.\n  return paramName; // Fallback for mock simplicity, real tests need accurate keyword\n}\n\ndescribe('guessPagination()', () => {\n  describe('No Pagination Detected', () => {\n    test('should return \"none\" for an operation with an empty parameters array', () => {\n      const op = createOperation([]);\n      assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n    });\n\n    test('should return \"none\" for an operation with undefined parameters', () => {\n      const op = createOperation(undefined as never);\n      assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n    });\n\n    test('should return \"none\" for non-pagination query parameters', () => {\n      const op = createOperation([qParam('search'), qParam('filterBy')]);\n      assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n    });\n\n    test('should return \"none\" if relevant parameters are not in \"query\"', () => {\n      const op = createOperation([hParam('offset'), hParam('limit')]);\n      assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n    });\n\n    test('should return \"none\" if only one part of a pair is present (e.g., only offset)', () => {\n      assert.deepStrictEqual(\n        guessPagination(createOperation([qParam('offset')])),\n        { type: 'none' },\n        'Only offset',\n      );\n      assert.deepStrictEqual(\n        guessPagination(createOperation([qParam('page')])),\n        { type: 'none' },\n        'Only page',\n      );\n      assert.deepStrictEqual(\n        guessPagination(createOperation([qParam('cursor')])),\n        { type: 'none' },\n        'Only cursor',\n      );\n      assert.deepStrictEqual(\n        guessPagination(createOperation([qParam('limit')])),\n        { type: 'none' },\n        'Only limit',\n      );\n    });\n\n    test('should return \"none\" for mixed non-query and insufficient query params', () => {\n      const op = createOperation([\n        pParam('userId'),\n        qParam('offset'),\n        hParam('X-Request-ID'),\n      ]);\n      assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n    });\n  });\n\n  describe('Offset Pagination Detection', () => {\n    const testOffsetKeywords = [\n      'offset',\n      'skip',\n      'start',\n      'start_index',\n      'starting_at',\n      'from',\n      'Offset',\n      'SKIP',\n    ];\n    const testLimitKeywords = [\n      'limit',\n      'count',\n      'size',\n      'page_size',\n      'pageSize',\n      'max_results',\n      'take',\n      'Limit',\n      'COUNT',\n    ];\n\n    for (const offsetKey of testOffsetKeywords) {\n      for (const limitKey of testLimitKeywords) {\n        if (offsetKey.toLowerCase() === limitKey.toLowerCase()) continue;\n\n        test(`should detect offset with \"${offsetKey}\" and \"${limitKey}\"`, () => {\n          const op = createOperation([qParam(offsetKey), qParam(limitKey)]);\n          const result = guessPagination(op);\n          // Note: With a simple mock, these detailed assertions might fail.\n          // They are designed for the actual implementation.\n          assert.strictEqual(\n            result.type,\n            'offset',\n            `Failed for ${offsetKey}, ${limitKey}`,\n          );\n          assert.strictEqual(result.offsetParamName, offsetKey);\n          assert.strictEqual(\n            result.offsetKeyword,\n            getExpectedKeyword(offsetKey, OFFSET_PARAM_REGEXES),\n          );\n          assert.strictEqual(result.limitParamName, limitKey);\n          assert.strictEqual(\n            result.limitKeyword,\n            getExpectedKeyword(limitKey, GENERIC_LIMIT_PARAM_REGEXES),\n          );\n        });\n      }\n    }\n\n    test('should not detect offset if one param is not in query', () => {\n      const op = createOperation([hParam('offset'), qParam('limit')]);\n      assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n    });\n\n    test('should not detect with two offset-like params and no limit', () => {\n      const op = createOperation([qParam('offset'), qParam('skip')]);\n      assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n    });\n\n    test('should correctly handle params in different order', () => {\n      const op = createOperation([qParam('limit'), qParam('offset')]);\n      const result = guessPagination(op);\n      assert.strictEqual(result.type, 'offset');\n      assert.strictEqual(result.offsetParamName, 'offset');\n      assert.strictEqual(result.limitParamName, 'limit');\n    });\n\n    test('should handle extra non-pagination params', () => {\n      const op = createOperation([\n        qParam('filter'),\n        qParam('offset'),\n        qParam('sort'),\n        qParam('limit'),\n      ]);\n      const result = guessPagination(op);\n      assert.strictEqual(result.type, 'offset');\n      assert.strictEqual(result.offsetParamName, 'offset');\n      assert.strictEqual(result.limitParamName, 'limit');\n    });\n  });\n\n  describe('Page Pagination Detection', () => {\n    const testPageNumKeywords = [\n      'page',\n      'p',\n      'page_number',\n      'pageNum',\n      'page_idx',\n      'Page',\n      'P',\n    ];\n    const testPageSizeKeywords = [\n      'page_size',\n      'pageSize',\n      'size',\n      'limit',\n      'count',\n      'per_page',\n      'per-page',\n      'num_items',\n      'Size',\n      'LIMIT',\n    ];\n\n    for (const pageKey of testPageNumKeywords) {\n      for (const sizeKey of testPageSizeKeywords) {\n        if (pageKey.toLowerCase() === sizeKey.toLowerCase()) continue;\n\n        test(`should detect page with \"${pageKey}\" and \"${sizeKey}\"`, () => {\n          const op = createOperation([qParam(pageKey), qParam(sizeKey)]);\n          const result = guessPagination(op);\n          assert.strictEqual(\n            result.type,\n            'page',\n            `Failed for ${pageKey}, ${sizeKey}`,\n          );\n          assert.strictEqual(result.pageNumberParamName, pageKey);\n          assert.strictEqual(\n            result.pageNumberKeyword,\n            getExpectedKeyword(pageKey, PAGE_NUMBER_REGEXES),\n          );\n          assert.strictEqual(result.pageSizeParamName, sizeKey);\n          assert.strictEqual(\n            result.pageSizeKeyword,\n            getExpectedKeyword(sizeKey, PAGE_SIZE_REGEXES),\n          );\n        });\n      }\n    }\n    test('should not detect page if one param is not in query', () => {\n      const op = createOperation([hParam('page'), qParam('size')]);\n      assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n    });\n\n    test('should not detect with two page-number-like params and no size', () => {\n      const op = createOperation([qParam('page'), qParam('page_number')]);\n      assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n    });\n  });\n\n  describe('Cursor Pagination Detection', () => {\n    const testCursorKeywords = [\n      'cursor',\n      'after',\n      'before_cursor',\n      'next_page_token',\n      'pageToken',\n      'continuation_token',\n      'Cursor',\n      'AFTER',\n    ];\n    const testCursorLimitKeywords = [\n      'limit',\n      'count',\n      'size',\n      'first',\n      'last',\n      'page_size',\n      'num_items',\n      'take',\n      'First',\n      'LAST',\n    ];\n\n    for (const cursorKey of testCursorKeywords) {\n      for (const limitKey of testCursorLimitKeywords) {\n        if (cursorKey.toLowerCase() === limitKey.toLowerCase()) continue;\n\n        test(`should detect cursor with \"${cursorKey}\" and \"${limitKey}\"`, () => {\n          const op = createOperation([qParam(cursorKey), qParam(limitKey)]);\n          const result = guessPagination(op);\n          assert.strictEqual(\n            result.type,\n            'cursor',\n            `Failed for ${cursorKey}, ${limitKey}`,\n          );\n          assert.strictEqual(result.cursorParamName, cursorKey);\n          assert.strictEqual(\n            result.cursorKeyword,\n            getExpectedKeyword(cursorKey, CURSOR_REGEXES),\n          );\n          assert.strictEqual(result.limitParamName, limitKey);\n          assert.strictEqual(\n            result.limitKeyword,\n            getExpectedKeyword(limitKey, CURSOR_LIMIT_REGEXES),\n          );\n        });\n      }\n    }\n    test('should not detect cursor if one param is not in query', () => {\n      const op = createOperation([hParam('cursor'), qParam('first')]);\n      assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n    });\n\n    test('should not detect with two cursor-like params and no limit', () => {\n      const op = createOperation([qParam('cursor'), qParam('after')]);\n      assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n    });\n  });\n\n  describe('Pagination Type Precedence', () => {\n    test('Offset should take precedence over Page (e.g., \"skip\", \"limit\", \"page\")', () => {\n      // This test relies on the actual implementation's precedence logic.\n      // The simple mock might not reflect this correctly.\n      const op = createOperation([\n        qParam('skip'),\n        qParam('limit'),\n        qParam('page'),\n      ]);\n      const result = guessPagination(op); // Assuming 'skip'/'limit' makes it 'offset'\n      assert.strictEqual(result.type, 'offset');\n      if (result.type === 'offset') {\n        // Type guard for TS\n        assert.strictEqual(result.offsetParamName, 'skip');\n        assert.strictEqual(result.limitParamName, 'limit');\n      }\n    });\n\n    test('Offset should take precedence over Cursor (e.g., \"offset\", \"count\", \"after_token\")', () => {\n      const op = createOperation([\n        qParam('offset'),\n        qParam('count'),\n        qParam('after_token'),\n      ]);\n      const result = guessPagination(op);\n      assert.strictEqual(result.type, 'offset');\n      if (result.type === 'offset') {\n        assert.strictEqual(result.offsetParamName, 'offset');\n        assert.strictEqual(result.limitParamName, 'count');\n      }\n    });\n\n    test('Page should take precedence over Cursor (e.g., \"page\", \"size\", \"next_cursor\")', () => {\n      const op = createOperation([\n        qParam('page'),\n        qParam('size'),\n        qParam('next_cursor'),\n      ]);\n      const result = guessPagination(op);\n      assert.strictEqual(result.type, 'page');\n      if (result.type === 'page') {\n        assert.strictEqual(result.pageNumberParamName, 'page');\n        assert.strictEqual(result.pageSizeParamName, 'size');\n      }\n    });\n\n    test('Params like \"page\" and \"limit\" should resolve to Page pagination', () => {\n      const op = createOperation([qParam('page'), qParam('limit')]);\n      const result = guessPagination(op);\n      assert.strictEqual(result.type, 'page');\n      if (result.type === 'page') {\n        assert.strictEqual(result.pageNumberParamName, 'page');\n        assert.strictEqual(result.pageSizeParamName, 'limit');\n      }\n    });\n  });\n\n  describe('Regex Specificity and Word Boundaries', () => {\n    // These tests are highly dependent on the actual regexes and findParamAndKeyword logic.\n    // The simple mock won't pass these accurately.\n    test('should not match \"custom_offset\" as \"offset\" due to word boundary (with real implementation)', () => {\n      const op = createOperation([\n        qParam('custom_offset_param'),\n        qParam('limit'),\n      ]);\n      // Expectation with real implementation:\n      // assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n      // With current simple mock, this might pass if 'limit' alone is not enough.\n      assert.ok(\n        true,\n        'Test needs real implementation for accurate regex boundary check',\n      );\n    });\n\n    test('should match \"offset_custom\" for \"offset\" keyword (with real implementation)', () => {\n      const op = createOperation([qParam('offset_custom'), qParam('limit')]);\n      // Expectation with real implementation:\n      // const result = guessPagination(op);\n      // assert.strictEqual(result.type, 'offset');\n      // assert.strictEqual(result.offsetParamName, 'offset_custom');\n      // assert.strictEqual(result.offsetKeyword, 'offset');\n      assert.ok(\n        true,\n        'Test needs real implementation for accurate keyword extraction',\n      );\n    });\n\n    test('should match \"page\" exactly for page number, not \"my_page_details\" (with real implementation)', () => {\n      const op = createOperation([qParam('my_page_details'), qParam('size')]);\n      // assert.deepStrictEqual(guessPagination(op), { type: 'none' });\n      assert.ok(\n        true,\n        'Test needs real implementation for exact regex matching',\n      );\n    });\n\n    test('should match \"p\" exactly for page number (with real implementation)', () => {\n      const op = createOperation([qParam('p'), qParam('size')]);\n      // const result = guessPagination(op);\n      // assert.strictEqual(result.type, 'page');\n      // assert.strictEqual(result.pageNumberParamName, 'p');\n      // assert.strictEqual(result.pageNumberKeyword, 'p');\n      assert.ok(\n        true,\n        'Test needs real implementation for exact regex matching',\n      );\n    });\n  });\n});\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/lib/tune.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=tune.test.d.ts.map

package/dist/lib/tune.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tune.test.d.ts","sourceRoot":"","sources":["../../src/lib/tune.test.ts"],"names":[],"mappings":""}

package/dist/lib/tune.test.js

@@ -1,60 +0,0 @@
-import { merge } from "lodash-es";
-import { describe, it } from "node:test";
-import { toIR } from "./ir.ts";
-function createSpec(openapi) {
-  return toIR(
-    {
-      spec: merge(
-        {
-          openapi: "3.1.0",
-          info: {
-            title: "Test API",
-            version: "1.0.0"
-          },
-          components: {
-            schemas: {},
-            securitySchemes: {}
-          },
-          paths: {}
-        },
-        openapi
-      )
-    },
-    true
-  );
-}
-describe("merge allof", () => {
-  it("should handle circular allOf references without stack overflow", () => {
-    const spec = createSpec({
-      components: {
-        schemas: {
-          A: {
-            allOf: [
-              { $ref: "#/components/schemas/B" },
-              {
-                type: "object",
-                properties: {
-                  nameA: { type: "string" }
-                }
-              }
-            ]
-          },
-          B: {
-            allOf: [
-              { $ref: "#/components/schemas/A" },
-              {
-                type: "object",
-                properties: {
-                  nameB: { type: "string" }
-                }
-              }
-            ]
-          }
-        }
-      }
-    });
-    const schemaA = spec.components.schemas.A;
-    console.dir(spec.components.schemas, { depth: null });
-  });
-});
-//# sourceMappingURL=tune.test.js.map

package/dist/lib/tune.test.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/lib/tune.test.ts"],
-  "sourcesContent": ["import { merge } from 'lodash-es';\nimport { describe, it } from 'node:test';\nimport type { OpenAPIObject, SchemaObject } from 'openapi3-ts/oas31';\n\nimport { toIR } from './ir.ts';\nimport type { IR } from './types.ts';\n\nfunction createSpec(openapi?: Partial<OpenAPIObject>): IR {\n  return toIR(\n    {\n      spec: merge(\n        {\n          openapi: '3.1.0',\n          info: {\n            title: 'Test API',\n            version: '1.0.0',\n          },\n          components: {\n            schemas: {},\n            securitySchemes: {},\n          },\n          paths: {},\n        },\n        openapi,\n      ),\n    },\n    true,\n  );\n}\n\ndescribe('merge allof', () => {\n  // it('should merge allOf schemas', () => {\n  //   const spec = createSpec({\n  //     components: {\n  //       schemas: {\n  //         Base: {\n  //           type: 'object',\n  //           properties: {\n  //             id: { type: 'string' },\n  //           },\n  //         },\n  //         Extended: {\n  //           allOf: [\n  //             { $ref: '#/components/schemas/Base' },\n  //             {\n  //               type: 'object',\n  //               properties: {\n  //                 name: { type: 'string' },\n  //               },\n  //             },\n  //           ],\n  //         },\n  //       },\n  //     },\n  //   });\n\n  //   const extendedSchema = spec.components.schemas.Extended as SchemaObject;\n  //   console.log(extendedSchema);\n  //   assert.deepStrictEqual(extendedSchema.type, 'object');\n  //   assert.deepStrictEqual(extendedSchema.properties, {\n  //     id: { type: 'string' },\n  //     name: { type: 'string' },\n  //   });\n  // });\n  // it('should handle empty allOf', () => {\n  //   const spec = createSpec({\n  //     components: {\n  //       schemas: {\n  //         EmptyAllOf: {\n  //           allOf: [],\n  //         },\n  //       },\n  //     },\n  //   });\n\n  //   const emptySchema = spec.components.schemas.EmptyAllOf as SchemaObject;\n  //   assert.deepStrictEqual(emptySchema.allOf, undefined);\n  //   assert.deepStrictEqual(emptySchema.type, undefined);\n  // });\n  // it('should handle allOf with only references', () => {\n  //   const spec = createSpec({\n  //     components: {\n  //       schemas: {\n  //         Base: {\n  //           type: 'object',\n  //           properties: {\n  //             id: { type: 'string' },\n  //           },\n  //         },\n  //         Extended: {\n  //           allOf: [\n  //             {\n  //               $ref: '#/components/schemas/Base',\n  //             },\n  //           ],\n  //         },\n  //       },\n  //     },\n  //   });\n\n  //   const extendedSchema = spec.components.schemas.Extended as SchemaObject;\n  //   assert.deepStrictEqual(extendedSchema.type, 'object');\n  //   assert.deepStrictEqual(extendedSchema.properties, {\n  //     id: {\n  //       type: 'string',\n  //     },\n  //   });\n  // });\n\n  it('should handle circular allOf references without stack overflow', () => {\n    const spec = createSpec({\n      components: {\n        schemas: {\n          A: {\n            allOf: [\n              { $ref: '#/components/schemas/B' },\n              {\n                type: 'object',\n                properties: {\n                  nameA: { type: 'string' },\n                },\n              },\n            ],\n          },\n          B: {\n            allOf: [\n              { $ref: '#/components/schemas/A' },\n              {\n                type: 'object',\n                properties: {\n                  nameB: { type: 'string' },\n                },\n              },\n            ],\n          },\n        },\n      },\n    });\n\n    // This would cause a stack overflow with the current implementation\n    const schemaA = spec.components.schemas.A as SchemaObject;\n    console.dir(spec.components.schemas, { depth: null });\n    // The test should not throw RangeError: Maximum call stack size exceeded\n  });\n\n  // it('should handle circular allOf references without stack overflow', () => {\n  //   const spec = createSpec({\n  //     components: {\n  //       schemas: {\n  //         A: {\n  //           allOf: [\n  //             { $ref: '#/components/schemas/B' },\n  //             {\n  //               type: 'object',\n  //               properties: {\n  //                 nameA: { type: 'string' },\n  //               },\n  //             },\n  //           ],\n  //         },\n  //         B: {\n  //           allOf: [\n  //             { $ref: '#/components/schemas/A' },\n  //             {\n  //               type: 'object',\n  //               properties: {\n  //                 nameB: { type: 'string' },\n  //               },\n  //             },\n  //           ],\n  //         },\n  //       },\n  //     },\n  //   });\n\n  //   // This would cause a stack overflow with the current implementation\n  //   const schemaA = spec.components.schemas.A as SchemaObject;\n  //   console.dir(spec.components.schemas, { depth: null });\n  //   // The test should not throw RangeError: Maximum call stack size exceeded\n  // });\n\n  // it('should handle self-referencing allOf', () => {\n  //   const spec = createSpec({\n  //     components: {\n  //       schemas: {\n  //         SelfRef: {\n  //           allOf: [\n  //             { $ref: '#/components/schemas/SelfRef' },\n  //             {\n  //               type: 'object',\n  //               properties: {\n  //                 name: { type: 'string' },\n  //               },\n  //             },\n  //           ],\n  //         },\n  //       },\n  //     },\n  //   });\n\n  //   // This would also cause infinite recursion\n  //   const schema = spec.components.schemas.SelfRef as SchemaObject;\n  // });\n});\n"],
-  "mappings": "AAAA,SAAS,aAAa;AACtB,SAAS,UAAU,UAAU;AAG7B,SAAS,YAAY;AAGrB,SAAS,WAAW,SAAsC;AACxD,SAAO;AAAA,IACL;AAAA,MACE,MAAM;AAAA,QACJ;AAAA,UACE,SAAS;AAAA,UACT,MAAM;AAAA,YACJ,OAAO;AAAA,YACP,SAAS;AAAA,UACX;AAAA,UACA,YAAY;AAAA,YACV,SAAS,CAAC;AAAA,YACV,iBAAiB,CAAC;AAAA,UACpB;AAAA,UACA,OAAO,CAAC;AAAA,QACV;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,IACA;AAAA,EACF;AACF;AAEA,SAAS,eAAe,MAAM;AA+E5B,KAAG,kEAAkE,MAAM;AACzE,UAAM,OAAO,WAAW;AAAA,MACtB,YAAY;AAAA,QACV,SAAS;AAAA,UACP,GAAG;AAAA,YACD,OAAO;AAAA,cACL,EAAE,MAAM,yBAAyB;AAAA,cACjC;AAAA,gBACE,MAAM;AAAA,gBACN,YAAY;AAAA,kBACV,OAAO,EAAE,MAAM,SAAS;AAAA,gBAC1B;AAAA,cACF;AAAA,YACF;AAAA,UACF;AAAA,UACA,GAAG;AAAA,YACD,OAAO;AAAA,cACL,EAAE,MAAM,yBAAyB;AAAA,cACjC;AAAA,gBACE,MAAM;AAAA,gBACN,YAAY;AAAA,kBACV,OAAO,EAAE,MAAM,SAAS;AAAA,gBAC1B;AAAA,cACF;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF,CAAC;AAGD,UAAM,UAAU,KAAK,WAAW,QAAQ;AACxC,YAAQ,IAAI,KAAK,WAAW,SAAS,EAAE,OAAO,KAAK,CAAC;AAAA,EAEtD,CAAC;AA4DH,CAAC;",
-  "names": []
-}