Add creator list search term normalizer

src/modules/creator/creator.controller.ts

@@ -12,6 +12,7 @@
 import { safeIntParam } from '../../utils/query.utils';
 import { parsePublicQuery } from '../../utils/public-query-parse.utils';
 import { wrapPublicCreatorListResponse } from '../creators/public-creator-list-envelope.utils';
+import { resolveCreatorListLimit } from '../creators/creators.limit.utils';
 import { buildCreatorListRequestContext } from '../creators/creator-list-context.utils';
 import { normalizeCreatorListPage } from './creator-list-page.guard';
 import {
@@ -28,7 +29,7 @@
       label: 'Page',
    }),
    limit: safeIntParam({
-      defaultValue: PUBLIC_PAGE_PAGINATION_DEFAULTS.limit,
+      defaultValue: resolveCreatorListLimit() ?? PUBLIC_PAGE_PAGINATION_DEFAULTS.limit,
       min: MIN_PAGE_SIZE,
       max: MAX_PAGE_SIZE,
       label: 'Limit',
@@ -41,16 +42,18 @@
    try {
       const ctx = buildCreatorListRequestContext(req);
       const parsed = parsePublicQuery(LegacyCreatorQuerySchema, ctx.query);
+
       if (!parsed.ok) {
          return sendValidationError(
             res,
             'Invalid query parameters',
             parsed.details
          );
       }
-      const { limit, sortBy, sortOrder } = parsed.data;
-      const page = normalizeCreatorListPage(parsed.data.page);
+const { limit, sortBy, sortOrder } = parsed.data;
+const page = normalizeCreatorListPage(parsed.data.page);
 
+      const { page, limit, sortBy, sortOrder } = parsed.data;
       const sort = parseCreatorSortOptions(sortBy, sortOrder);
 
       const { creators, meta } = await getPaginatedCreators({

src/modules/creators/creators.limit.utils.ts

@@ -0,0 +1,10 @@
+import { DEFAULT_PAGE_SIZE } from '../../constants/pagination.constants';
+
+/**
+ * Resolve list limit for public creator list endpoints.
+ *
+ * Returns the shared default page size when the incoming page size is omitted.
+ */
+export function resolveCreatorListLimit(pageSize?: number): number {
+   return pageSize ?? DEFAULT_PAGE_SIZE;
+}

src/modules/creators/creators.schemas.ts

@@ -4,11 +4,14 @@ import { creatorListSortDirectionQueryParam } from './creators.sort-direction.pa
 import { withCreatorListQueryStringNormalization } from './creators.query-string.utils';
 import { safeIntParam } from '../../utils/query.utils';
 import {
-   MIN_PAGE_SIZE,
-   MAX_PAGE_SIZE,
+  MIN_PAGE_SIZE,
+  MAX_PAGE_SIZE,
 } from '../../constants/pagination.constants';
+
 import { PUBLIC_OFFSET_PAGINATION_DEFAULTS } from '../../utils/public-list-query-defaults';
 import { DEFAULT_CREATOR_LIST_SORT } from '../../constants/creator-list-sort.constants';
+import { resolveCreatorListLimit } from './creators.limit.utils';
+import { normalizeCreatorListSearchTerm } from './creators.search-term.utils';
 
 /**
  * Validation schema for creator list query parameters.
@@ -22,7 +25,7 @@ import { DEFAULT_CREATOR_LIST_SORT } from '../../constants/creator-list-sort.con
 export const CreatorListQuerySchema = z.object({
    // Pagination
    limit: safeIntParam({
-      defaultValue: PUBLIC_OFFSET_PAGINATION_DEFAULTS.limit,
+defaultValue: resolveCreatorListLimit() ?? PUBLIC_OFFSET_PAGINATION_DEFAULTS.limit,
       min: MIN_PAGE_SIZE,
       max: MAX_PAGE_SIZE,
       label: 'Limit',
@@ -50,7 +53,12 @@ export const CreatorListQuerySchema = z.object({
             return val === 'true';
          })
    ),
-   search: withCreatorListQueryStringNormalization(z.string().optional()),
+   search: withCreatorListQueryStringNormalization(
+      z
+         .string()
+         .optional()
+         .transform(val => normalizeCreatorListSearchTerm(val))
+   ),
 });
 
 export type CreatorListQueryType = z.infer<typeof CreatorListQuerySchema>;

src/modules/creators/creators.search-term.utils.ts

@@ -0,0 +1,20 @@
+/**
+ * Normalize free-text creator list search terms before filtering.
+ *
+ * Scope is intentionally narrow and reusable:
+ * - Accepts `string | null | undefined`
+ * - Trims leading/trailing whitespace
+ * - Collapses internal whitespace to single spaces
+ * - Returns `undefined` for empty/whitespace-only values
+ */
+export function normalizeCreatorListSearchTerm(
+   term: string | null | undefined
+): string | undefined {
+   if (typeof term !== 'string') {
+      return undefined;
+   }
+
+   const normalized = term.trim().replace(/\s+/g, ' ');
+   return normalized === '' ? undefined : normalized;
+}
+

src/modules/creators/creators.utils.ts

@@ -5,6 +5,7 @@ import { mapCreatorListSort } from './creators.sort';
 import { CreatorListResponse } from './creators.serializers';
 import { wrapPublicCreatorListResponse } from './public-creator-list-envelope.utils';
 import { buildOffsetPaginationMeta } from '../../utils/pagination.utils';
+import { normalizeCreatorListSearchTerm } from './creators.search-term.utils';
 
 type CreatorListWhere = {
    isVerified?: boolean;
@@ -32,10 +33,12 @@ export async function fetchCreatorList(
       where.isVerified = verified;
    }
 
-   if (search) {
+   const normalizedSearch = normalizeCreatorListSearchTerm(search);
+
+   if (normalizedSearch) {
       where.OR = [
-         { handle: { contains: search, mode: 'insensitive' } },
-         { displayName: { contains: search, mode: 'insensitive' } },
+         { handle: { contains: normalizedSearch, mode: 'insensitive' } },
+         { displayName: { contains: normalizedSearch, mode: 'insensitive' } },
       ];
    }