```ts
  handler: async (ctx, args) => {
    const user = await getCurrentUser(ctx);
    const workspace = await getWorkspace(ctx, user._id, args.workspaceId);

    let providers = await asyncMap(
      filter(
        ctx.db.query('providers').withIndex('by_workspace', (q) => q.eq('workspaceId', workspace._id)),
        (p) => (args.searchTerm ? p.name.toLowerCase().includes(args.searchTerm) : true)
      ).collect(),
      async (provider) => {
        const records = await getManyFrom(ctx.db, 'records', 'by_provider', provider._id, 'providerId');

        const now = Date.now();
        const expired = records.reduce((count, record) => {
          const isExpired = new Date(record.value).getTime() <= now;
          return count + (isExpired ? 1 : 0);
        }, 0);
        const expiringSoon =
          records.reduce((count, record) => {
            const within30Days = new Date(record.value).getTime() - now <= 30 * 24 * 60 * 60 * 1000;
            return count + (within30Days ? 1 : 0);
          }, 0) - expired;

        return {
          ...provider,
          expired,
          expiringSoon,
          totalRecords: records.length,
          status: expired > 0 ? 'overdue' : expiringSoon > 0 ? 'warning' : 'compliant',
        };
      }
    );

    providers.sort((a, b) => a.name.localeCompare(b.name));
    if (args.sortDirection === 'desc') providers.reverse();

    if (args.statusFilter.length > 0) {
      providers = providers.filter((p) => {
        if (args.statusFilter.includes('compliant') && p.expiringSoon === 0 && p.expired === 0) return true;
        if (args.statusFilter.includes('warning') && p.expiringSoon > 0 && p.expired === 0) return true;
        if (args.statusFilter.includes('overdue') && p.expired > 0) return true;
        return false;
      });
    }
    if (args.sortBy === 'status') {
      const statusRank: Record<string, number> = {
        compliant: 0,
        warning: 1,
        overdue: 2,
      };
      providers.sort((a, b) => {
        const order = args.sortDirection === 'asc' ? 1 : -1;
        return (statusRank[a.status] - statusRank[b.status]) * order;
      });
    }

    const count = providers.length;

    const start = (args.page - 1) * args.pageSize;
    const end = start + args.pageSize;
    providers = providers.slice(start, end);

    const totalPages = Math.ceil(count / args.pageSize);

    return {
      providers,
      totalProviders: count,
      totalPages,
      nextPage: args.page < totalPages ? args.page + 1 : null,
    };
  },
```