@longzai-intelligence/pagination 0.0.1 → 0.0.3

package/src/__tests__/pagination.util.test.ts

@@ -1,253 +0,0 @@
-/**
- * @file pagination.util.test.ts
- * 分页计算工具函数测试
- * @author Longzai Intelligence
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  normalizePagination,
-  normalizeOffsetPagination,
-  calculateOffset,
-  calculateTotalPages,
-  hasNextPage,
-  hasPreviousPage,
-  offsetToPage,
-  pageToOffset,
-  createPaginatedResult,
-} from '@/utils/pagination.util';
-import { PAGINATION_DEFAULTS } from '@/types';
-
-describe('normalizePagination', () => {
-  it('应返回默认值当参数为空时', () => {
-    const result = normalizePagination();
-    expect(result).toEqual({
-      page: PAGINATION_DEFAULTS.page,
-      pageSize: PAGINATION_DEFAULTS.pageSize,
-    });
-  });
-
-  it('应返回默认值当参数为 undefined 时', () => {
-    const result = normalizePagination(undefined);
-    expect(result).toEqual({
-      page: PAGINATION_DEFAULTS.page,
-      pageSize: PAGINATION_DEFAULTS.pageSize,
-    });
-  });
-
-  it('应正确规范化有效的分页参数', () => {
-    const result = normalizePagination({ page: 2, pageSize: 50 });
-    expect(result).toEqual({ page: 2, pageSize: 50 });
-  });
-
-  it('应限制 pageSize 不超过最大值', () => {
-    const result = normalizePagination({ pageSize: 200 });
-    expect(result.pageSize).toBe(PAGINATION_DEFAULTS.maxPageSize);
-  });
-
-  it('应限制 pageSize 不小于最小值', () => {
-    const result = normalizePagination({ pageSize: 0 });
-    expect(result.pageSize).toBe(PAGINATION_DEFAULTS.minPageSize);
-  });
-
-  it('应限制 page 不小于 1', () => {
-    const result = normalizePagination({ page: -1 });
-    expect(result.page).toBe(1);
-  });
-
-  it('应正确处理小数值', () => {
-    const result = normalizePagination({ page: 1.5, pageSize: 10.9 });
-    expect(result).toEqual({ page: 1, pageSize: 10 });
-  });
-
-  it('应正确处理部分参数', () => {
-    const result = normalizePagination({ page: 5 });
-    expect(result).toEqual({ page: 5, pageSize: PAGINATION_DEFAULTS.pageSize });
-  });
-});
-
-describe('normalizeOffsetPagination', () => {
-  it('应返回默认值当参数为空时', () => {
-    const result = normalizeOffsetPagination();
-    expect(result).toEqual({
-      limit: PAGINATION_DEFAULTS.pageSize,
-      offset: 0,
-    });
-  });
-
-  it('应正确规范化有效的 offset 分页参数', () => {
-    const result = normalizeOffsetPagination({ limit: 50, offset: 100 });
-    expect(result).toEqual({ limit: 50, offset: 100 });
-  });
-
-  it('应限制 limit 不超过最大值', () => {
-    const result = normalizeOffsetPagination({ limit: 200 });
-    expect(result.limit).toBe(PAGINATION_DEFAULTS.maxPageSize);
-  });
-
-  it('应限制 limit 不小于最小值', () => {
-    const result = normalizeOffsetPagination({ limit: 0 });
-    expect(result.limit).toBe(PAGINATION_DEFAULTS.minPageSize);
-  });
-
-  it('应限制 offset 不小于 0', () => {
-    const result = normalizeOffsetPagination({ offset: -10 });
-    expect(result.offset).toBe(0);
-  });
-
-  it('应正确处理小数值', () => {
-    const result = normalizeOffsetPagination({ limit: 10.9, offset: 50.5 });
-    expect(result).toEqual({ limit: 10, offset: 50 });
-  });
-});
-
-describe('calculateOffset', () => {
-  it('应正确计算第一页的偏移量', () => {
-    expect(calculateOffset(1, 20)).toBe(0);
-  });
-
-  it('应正确计算第二页的偏移量', () => {
-    expect(calculateOffset(2, 20)).toBe(20);
-  });
-
-  it('应正确计算任意页的偏移量', () => {
-    expect(calculateOffset(5, 10)).toBe(40);
-  });
-
-  it('应正确处理不同的页面大小', () => {
-    expect(calculateOffset(3, 50)).toBe(100);
-  });
-});
-
-describe('calculateTotalPages', () => {
-  it('应正确计算总页数', () => {
-    expect(calculateTotalPages(100, 20)).toBe(5);
-  });
-
-  it('应正确处理有余数的情况', () => {
-    expect(calculateTotalPages(95, 20)).toBe(5);
-  });
-
-  it('应正确处理总数为 0 的情况', () => {
-    expect(calculateTotalPages(0, 20)).toBe(0);
-  });
-
-  it('应正确处理总数小于页面大小的情况', () => {
-    expect(calculateTotalPages(15, 20)).toBe(1);
-  });
-
-  it('应正确处理 pageSize 为 0 的情况', () => {
-    expect(calculateTotalPages(100, 0)).toBe(0);
-  });
-});
-
-describe('hasNextPage', () => {
-  it('应返回 true 当有下一页时', () => {
-    expect(hasNextPage(1, 5)).toBe(true);
-  });
-
-  it('应返回 false 当在最后一页时', () => {
-    expect(hasNextPage(5, 5)).toBe(false);
-  });
-
-  it('应返回 false 当总页数为 0 时', () => {
-    expect(hasNextPage(1, 0)).toBe(false);
-  });
-});
-
-describe('hasPreviousPage', () => {
-  it('应返回 false 当在第一页时', () => {
-    expect(hasPreviousPage(1)).toBe(false);
-  });
-
-  it('应返回 true 当不在第一页时', () => {
-    expect(hasPreviousPage(2)).toBe(true);
-  });
-
-  it('应返回 true 当在大页码时', () => {
-    expect(hasPreviousPage(100)).toBe(true);
-  });
-});
-
-describe('offsetToPage', () => {
-  it('应正确转换 offset 0 到第一页', () => {
-    expect(offsetToPage(0, 20)).toEqual({ page: 1, pageSize: 20 });
-  });
-
-  it('应正确转换 offset 到对应页', () => {
-    expect(offsetToPage(40, 20)).toEqual({ page: 3, pageSize: 20 });
-  });
-
-  it('应正确处理非整除情况', () => {
-    expect(offsetToPage(25, 20)).toEqual({ page: 2, pageSize: 20 });
-  });
-
-  it('应正确处理 limit 为 0 的情况', () => {
-    expect(offsetToPage(0, 0)).toEqual({ page: 1, pageSize: 1 });
-  });
-});
-
-describe('pageToOffset', () => {
-  it('应正确转换第一页到 offset 0', () => {
-    expect(pageToOffset(1, 20)).toEqual({ offset: 0, limit: 20 });
-  });
-
-  it('应正确转换页码到 offset', () => {
-    expect(pageToOffset(3, 20)).toEqual({ offset: 40, limit: 20 });
-  });
-
-  it('应正确处理 page 为 0 的情况', () => {
-    expect(pageToOffset(0, 20)).toEqual({ offset: 0, limit: 20 });
-  });
-
-  it('应正确处理 pageSize 为 0 的情况', () => {
-    expect(pageToOffset(1, 0)).toEqual({ offset: 0, limit: 1 });
-  });
-});
-
-describe('createPaginatedResult', () => {
-  it('应正确创建分页结果', () => {
-    const items = [1, 2, 3];
-    const result = createPaginatedResult(items, 100, 2, 20);
-
-    expect(result).toEqual({
-      items,
-      total: 100,
-      page: 2,
-      pageSize: 20,
-      totalPages: 5,
-      hasNextPage: true,
-      hasPreviousPage: true,
-    });
-  });
-
-  it('应正确处理第一页', () => {
-    const items = [1, 2, 3];
-    const result = createPaginatedResult(items, 100, 1, 20);
-
-    expect(result.hasPreviousPage).toBe(false);
-    expect(result.hasNextPage).toBe(true);
-  });
-
-  it('应正确处理最后一页', () => {
-    const items = [1, 2, 3];
-    const result = createPaginatedResult(items, 100, 5, 20);
-
-    expect(result.hasPreviousPage).toBe(true);
-    expect(result.hasNextPage).toBe(false);
-  });
-
-  it('应正确处理空结果', () => {
-    const result = createPaginatedResult([], 0, 1, 20);
-
-    expect(result).toEqual({
-      items: [],
-      total: 0,
-      page: 1,
-      pageSize: 20,
-      totalPages: 0,
-      hasNextPage: false,
-      hasPreviousPage: false,
-    });
-  });
-});

package/src/__tests__/typeorm.adapter.test.ts

@@ -1,214 +0,0 @@
-/**
- * @file typeorm.adapter.test.ts
- * TypeORM 适配器测试
- * @author Longzai Intelligence
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import {
-  paginateWithRepository,
-  paginateWithQueryBuilder,
-  createPaginationQueryBuilder,
-} from '@/adapters/typeorm.adapter';
-import type { Repository, SelectQueryBuilder, FindOptionsOrder } from 'typeorm';
-
-/**
- * 测试实体类型
- *
- * 用于测试的简单实体定义
- */
-type TestEntity = {
-  id: number;
-  name?: string;
-  status?: string;
-  createdAt?: Date;
-};
-
-/**
- * 映射后的 DTO 类型
- */
-type MappedDto = {
-  mapped: TestEntity;
-};
-
-/**
- * 创建模拟的 Repository
- *
- * @returns 模拟的 Repository 对象
- */
-function createMockRepository(): Repository<TestEntity> {
-  return {
-    findAndCount: vi.fn(),
-    createQueryBuilder: vi.fn(),
-    metadata: {
-      name: 'TestEntity',
-    },
-  } as Repository<TestEntity>;
-}
-
-/**
- * 创建模拟的 QueryBuilder
- *
- * @returns 模拟的 QueryBuilder 对象
- */
-function createMockQueryBuilder(): SelectQueryBuilder<TestEntity> {
-  return {
-    skip: vi.fn().mockReturnThis(),
-    take: vi.fn().mockReturnThis(),
-    getManyAndCount: vi.fn(),
-  } as SelectQueryBuilder<TestEntity>;
-}
-
-describe('paginateWithRepository', () => {
-  it('应正确执行分页查询', async () => {
-    const mockRepository = createMockRepository();
-
-    const mockEntities: TestEntity[] = [{ id: 1 }, { id: 2 }];
-    vi.mocked(mockRepository.findAndCount).mockResolvedValue([mockEntities, 10]);
-
-    const result = await paginateWithRepository(mockRepository, { page: 1, pageSize: 10 });
-
-    expect(result).toEqual({
-      items: mockEntities,
-      total: 10,
-      page: 1,
-      pageSize: 10,
-      totalPages: 1,
-      hasNextPage: false,
-      hasPreviousPage: false,
-    });
-  });
-
-  it('应正确使用自定义映射函数', async () => {
-    const mockRepository = createMockRepository();
-
-    const mockEntities: TestEntity[] = [{ id: 1 }, { id: 2 }];
-    vi.mocked(mockRepository.findAndCount).mockResolvedValue([mockEntities, 10]);
-
-    const mapper = (entity: TestEntity): MappedDto => ({ mapped: entity });
-    const result = await paginateWithRepository(
-      mockRepository,
-      { page: 1, pageSize: 10 },
-      {
-        mapper,
-      },
-    );
-
-    expect(result.items).toEqual([{ mapped: { id: 1 } }, { mapped: { id: 2 } }]);
-  });
-
-  it('应正确处理分页参数', async () => {
-    const mockRepository = createMockRepository();
-
-    const mockEntities: TestEntity[] = [{ id: 1 }];
-    vi.mocked(mockRepository.findAndCount).mockResolvedValue([mockEntities, 100]);
-
-    const result = await paginateWithRepository(mockRepository, { page: 2, pageSize: 20 });
-
-    expect(result.page).toBe(2);
-    expect(result.pageSize).toBe(20);
-    expect(result.totalPages).toBe(5);
-    expect(result.hasNextPage).toBe(true);
-    expect(result.hasPreviousPage).toBe(true);
-  });
-
-  it('应正确使用查询选项', async () => {
-    const mockRepository = createMockRepository();
-
-    const mockEntities: TestEntity[] = [{ id: 1 }];
-    vi.mocked(mockRepository.findAndCount).mockResolvedValue([mockEntities, 10]);
-
-    const options = {
-      where: { status: 'active' },
-      order: { createdAt: 'DESC' } as FindOptionsOrder<TestEntity>,
-      relations: ['user'],
-      select: ['id', 'name'],
-    };
-
-    await paginateWithRepository(mockRepository, { page: 1, pageSize: 10 }, options);
-
-    expect(mockRepository.findAndCount).toHaveBeenCalledWith(
-      expect.objectContaining({
-        skip: 0,
-        take: 10,
-        where: options.where,
-        order: options.order,
-        relations: options.relations,
-        select: options.select,
-      }),
-    );
-  });
-});
-
-describe('paginateWithQueryBuilder', () => {
-  it('应正确执行分页查询', async () => {
-    const mockQueryBuilder = createMockQueryBuilder();
-
-    const mockEntities: TestEntity[] = [{ id: 1 }, { id: 2 }];
-    vi.mocked(mockQueryBuilder.getManyAndCount).mockResolvedValue([mockEntities, 10]);
-
-    const result = await paginateWithQueryBuilder(mockQueryBuilder, { page: 1, pageSize: 10 });
-
-    expect(result).toEqual({
-      items: mockEntities,
-      total: 10,
-      page: 1,
-      pageSize: 10,
-      totalPages: 1,
-      hasNextPage: false,
-      hasPreviousPage: false,
-    });
-  });
-
-  it('应正确使用自定义映射函数', async () => {
-    const mockQueryBuilder = createMockQueryBuilder();
-
-    const mockEntities: TestEntity[] = [{ id: 1 }, { id: 2 }];
-    vi.mocked(mockQueryBuilder.getManyAndCount).mockResolvedValue([mockEntities, 10]);
-
-    const mapper = (entity: TestEntity): MappedDto => ({ mapped: entity });
-    const result = await paginateWithQueryBuilder(
-      mockQueryBuilder,
-      { page: 1, pageSize: 10 },
-      mapper,
-    );
-
-    expect(result.items).toEqual([{ mapped: { id: 1 } }, { mapped: { id: 2 } }]);
-  });
-
-  it('应正确设置 skip 和 take', async () => {
-    const mockQueryBuilder = createMockQueryBuilder();
-
-    vi.mocked(mockQueryBuilder.getManyAndCount).mockResolvedValue([[], 0]);
-
-    await paginateWithQueryBuilder(mockQueryBuilder, { page: 2, pageSize: 20 });
-
-    expect(mockQueryBuilder.skip).toHaveBeenCalledWith(20);
-    expect(mockQueryBuilder.take).toHaveBeenCalledWith(20);
-  });
-});
-
-describe('createPaginationQueryBuilder', () => {
-  it('应正确创建 QueryBuilder', () => {
-    const mockQueryBuilder = createMockQueryBuilder();
-
-    const mockRepository = createMockRepository();
-    vi.mocked(mockRepository.createQueryBuilder).mockReturnValue(mockQueryBuilder);
-
-    const result = createPaginationQueryBuilder(mockRepository);
-
-    expect(result).toBe(mockQueryBuilder);
-    expect(mockRepository.createQueryBuilder).toHaveBeenCalled();
-  });
-
-  it('应使用自定义别名', () => {
-    const mockQueryBuilder = createMockQueryBuilder();
-
-    const mockRepository = createMockRepository();
-    vi.mocked(mockRepository.createQueryBuilder).mockReturnValue(mockQueryBuilder);
-
-    createPaginationQueryBuilder(mockRepository, 'custom_alias');
-
-    expect(mockRepository.createQueryBuilder).toHaveBeenCalledWith('custom_alias');
-  });
-});

package/src/__tests__/validation.util.test.ts

@@ -1,122 +0,0 @@
-/**
- * @file validation.util.test.ts
- * 分页参数验证工具函数测试
- * @author Longzai Intelligence
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  isValidPage,
-  isValidPageSize,
-  isValidOffset,
-  isValidLimit,
-  isValidPagination,
-  isValidOffsetPagination,
-} from '@/utils/validation.util';
-import { PAGINATION_DEFAULTS } from '@/types';
-
-describe('isValidPage', () => {
-  it('应返回 true 对于有效的页码', () => {
-    expect(isValidPage(1)).toBe(true);
-    expect(isValidPage(10)).toBe(true);
-    expect(isValidPage(1000)).toBe(true);
-  });
-
-  it('应返回 false 对于无效的页码', () => {
-    expect(isValidPage(0)).toBe(false);
-    expect(isValidPage(-1)).toBe(false);
-    expect(isValidPage(1.5)).toBe(false);
-    expect(isValidPage('1')).toBe(false);
-    expect(isValidPage(null)).toBe(false);
-    expect(isValidPage(undefined)).toBe(false);
-    expect(isValidPage(NaN)).toBe(false);
-  });
-});
-
-describe('isValidPageSize', () => {
-  it('应返回 true 对于有效的页面大小', () => {
-    expect(isValidPageSize(1)).toBe(true);
-    expect(isValidPageSize(20)).toBe(true);
-    expect(isValidPageSize(PAGINATION_DEFAULTS.maxPageSize)).toBe(true);
-  });
-
-  it('应返回 false 对于无效的页面大小', () => {
-    expect(isValidPageSize(0)).toBe(false);
-    expect(isValidPageSize(-1)).toBe(false);
-    expect(isValidPageSize(PAGINATION_DEFAULTS.maxPageSize + 1)).toBe(false);
-    expect(isValidPageSize(1.5)).toBe(false);
-    expect(isValidPageSize('20')).toBe(false);
-    expect(isValidPageSize(null)).toBe(false);
-    expect(isValidPageSize(undefined)).toBe(false);
-  });
-});
-
-describe('isValidOffset', () => {
-  it('应返回 true 对于有效的偏移量', () => {
-    expect(isValidOffset(0)).toBe(true);
-    expect(isValidOffset(10)).toBe(true);
-    expect(isValidOffset(1000)).toBe(true);
-  });
-
-  it('应返回 false 对于无效的偏移量', () => {
-    expect(isValidOffset(-1)).toBe(false);
-    expect(isValidOffset(1.5)).toBe(false);
-    expect(isValidOffset('10')).toBe(false);
-    expect(isValidOffset(null)).toBe(false);
-    expect(isValidOffset(undefined)).toBe(false);
-  });
-});
-
-describe('isValidLimit', () => {
-  it('应返回 true 对于有效的限制数量', () => {
-    expect(isValidLimit(1)).toBe(true);
-    expect(isValidLimit(20)).toBe(true);
-    expect(isValidLimit(PAGINATION_DEFAULTS.maxPageSize)).toBe(true);
-  });
-
-  it('应返回 false 对于无效的限制数量', () => {
-    expect(isValidLimit(0)).toBe(false);
-    expect(isValidLimit(-1)).toBe(false);
-    expect(isValidLimit(PAGINATION_DEFAULTS.maxPageSize + 1)).toBe(false);
-    expect(isValidLimit(1.5)).toBe(false);
-    expect(isValidLimit('20')).toBe(false);
-    expect(isValidLimit(null)).toBe(false);
-    expect(isValidLimit(undefined)).toBe(false);
-  });
-});
-
-describe('isValidPagination', () => {
-  it('应返回 true 对于有效的分页参数', () => {
-    expect(isValidPagination({ page: 1, pageSize: 20 })).toBe(true);
-    expect(isValidPagination({ page: 5 })).toBe(true);
-    expect(isValidPagination({ pageSize: 50 })).toBe(true);
-    expect(isValidPagination({})).toBe(true);
-  });
-
-  it('应返回 false 对于无效的分页参数', () => {
-    expect(isValidPagination(null)).toBe(false);
-    expect(isValidPagination('string')).toBe(false);
-    expect(isValidPagination(123)).toBe(false);
-    expect(isValidPagination({ page: -1 })).toBe(false);
-    expect(isValidPagination({ pageSize: 0 })).toBe(false);
-    expect(isValidPagination({ page: 1.5 })).toBe(false);
-  });
-});
-
-describe('isValidOffsetPagination', () => {
-  it('应返回 true 对于有效的 offset 分页参数', () => {
-    expect(isValidOffsetPagination({ limit: 20, offset: 0 })).toBe(true);
-    expect(isValidOffsetPagination({ limit: 50 })).toBe(true);
-    expect(isValidOffsetPagination({ offset: 100 })).toBe(true);
-    expect(isValidOffsetPagination({})).toBe(true);
-  });
-
-  it('应返回 false 对于无效的 offset 分页参数', () => {
-    expect(isValidOffsetPagination(null)).toBe(false);
-    expect(isValidOffsetPagination('string')).toBe(false);
-    expect(isValidOffsetPagination(123)).toBe(false);
-    expect(isValidOffsetPagination({ offset: -1 })).toBe(false);
-    expect(isValidOffsetPagination({ limit: 0 })).toBe(false);
-    expect(isValidOffsetPagination({ limit: 1.5 })).toBe(false);
-  });
-});

package/src/adapters/index.ts

@@ -1,11 +0,0 @@
-/**
- * 适配器导出入口
- */
-
-export type { EntityMapper, TypeOrmPaginateOptions } from './typeorm.adapter';
-
-export {
-  paginateWithRepository,
-  paginateWithQueryBuilder,
-  createPaginationQueryBuilder,
-} from './typeorm.adapter';