@open-mercato/core 0.4.11-develop.1355.50152f3ee9 → 0.4.11-develop.1362.574a071900

package/src/modules/customers/api/utils.ts

@@ -1,4 +1,12 @@
 import { createScopedApiHelpers } from '@open-mercato/shared/lib/api/scoped'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { CrudCtx } from '@open-mercato/shared/lib/crud/factory'
+import type { EntityId } from '@open-mercato/shared/modules/entities'
+import type { QueryCustomFieldSource, QueryJoinEdge, QueryEngine } from '@open-mercato/shared/lib/query/types'
+import { resolveSearchConfig } from '@open-mercato/shared/lib/search/config'
+import { tokenizeText } from '@open-mercato/shared/lib/search/tokenize'
+import { deserializeAdvancedFilter } from '@open-mercato/shared/lib/query/advanced-filter'
+import { SortDir } from '@open-mercato/shared/lib/query/types'
 
 const { withScopedPayload, parseScopedCommandInput } = createScopedApiHelpers({
   messages: {
@@ -7,4 +15,282 @@ const { withScopedPayload, parseScopedCommandInput } = createScopedApiHelpers({
   },
 })
 
+const NO_MATCH_ID = '00000000-0000-0000-0000-000000000000'
+
+type SearchTokenMatchInput = {
+  ctx: CrudCtx
+  entityType: string
+  fields: string[]
+  query: string
+}
+
+type SearchTokenSource = {
+  entityType: string
+  fields: string[]
+  mapToEntityIds?: {
+    table: string
+    sourceColumn?: string
+    targetColumn: string
+    tenantColumn?: string
+    organizationColumn?: string
+  }
+}
+
+async function enrichSearchSourcesWithCustomFieldTokens(
+  ctx: CrudCtx,
+  sources: SearchTokenSource[],
+): Promise<SearchTokenSource[]> {
+  const entityTypes = Array.from(
+    new Set(
+      sources
+        .map((source) => source.entityType)
+        .filter((value): value is string => typeof value === 'string' && value.length > 0),
+    ),
+  )
+  if (!entityTypes.length) return sources
+
+  const em = ctx.container.resolve('em') as EntityManager
+  const knex = (em as any).getConnection().getKnex()
+  let defsQuery = knex('custom_field_defs')
+    .select('entity_id', 'key', 'kind')
+    .whereIn('entity_id', entityTypes)
+    .andWhere('is_active', true)
+
+  defsQuery = defsQuery.andWhere((builder: any) => {
+    builder.where({ tenant_id: ctx.auth?.tenantId ?? null }).orWhereNull('tenant_id')
+  })
+
+  if (ctx.selectedOrganizationId) {
+    defsQuery = defsQuery.andWhere((builder: any) => {
+      builder.where({ organization_id: ctx.selectedOrganizationId }).orWhereNull('organization_id')
+    })
+  } else if (Array.isArray(ctx.organizationIds) && ctx.organizationIds.length > 0) {
+    defsQuery = defsQuery.andWhere((builder: any) => {
+      builder.whereIn('organization_id', ctx.organizationIds).orWhereNull('organization_id')
+    })
+  }
+
+  const customFieldKeysByEntity = new Map<string, Set<string>>()
+  const rows = await defsQuery
+  for (const row of rows as Array<{ entity_id?: unknown; key?: unknown; kind?: unknown }>) {
+    if (row.kind === 'attachment') continue
+    const entityType = typeof row.entity_id === 'string' ? row.entity_id : null
+    const key = typeof row.key === 'string' ? row.key.trim() : ''
+    if (!entityType || !key) continue
+    const bucket = customFieldKeysByEntity.get(entityType) ?? new Set<string>()
+    bucket.add(`cf:${key}`)
+    customFieldKeysByEntity.set(entityType, bucket)
+  }
+
+  return sources.map((source) => {
+    const customFieldKeys = customFieldKeysByEntity.get(source.entityType)
+    return {
+      ...source,
+      fields: Array.from(new Set([
+        'search_text',
+        ...source.fields,
+        ...(customFieldKeys ? Array.from(customFieldKeys) : []),
+      ])),
+    }
+  })
+}
+
+async function findSearchTokenEntityIds({
+  ctx,
+  entityType,
+  fields,
+  query,
+}: SearchTokenMatchInput): Promise<string[] | null> {
+  const trimmed = query.trim()
+  if (!trimmed) return null
+
+  const tokens = tokenizeText(trimmed, resolveSearchConfig())
+  if (!tokens.hashes.length) return []
+
+  const em = ctx.container.resolve('em') as EntityManager
+  const knex = (em as any).getConnection().getKnex()
+  let searchQuery = knex('search_tokens')
+    .select('entity_id')
+    .where('entity_type', entityType)
+    .whereIn('field', fields)
+    .whereIn('token_hash', tokens.hashes)
+    .groupBy('entity_id')
+    .havingRaw('count(distinct token_hash) >= ?', [tokens.hashes.length])
+
+  if (ctx.auth?.tenantId !== undefined) {
+    searchQuery = searchQuery.whereRaw('tenant_id is not distinct from ?', [ctx.auth?.tenantId ?? null])
+  }
+  if (ctx.selectedOrganizationId) {
+    searchQuery = searchQuery.where('organization_id', ctx.selectedOrganizationId)
+  } else if (Array.isArray(ctx.organizationIds) && ctx.organizationIds.length > 0) {
+    searchQuery = searchQuery.whereIn('organization_id', ctx.organizationIds)
+  }
+
+  const rows = await searchQuery
+  return rows
+    .map((row: { entity_id?: unknown }) => (typeof row.entity_id === 'string' ? row.entity_id : null))
+    .filter((id: string | null): id is string => typeof id === 'string' && id.length > 0)
+}
+
+async function mapScopedEntityIds({
+  ctx,
+  ids,
+  config,
+}: {
+  ctx: CrudCtx
+  ids: string[]
+  config: NonNullable<SearchTokenSource['mapToEntityIds']>
+}): Promise<string[]> {
+  if (!ids.length) return []
+
+  const em = ctx.container.resolve('em') as EntityManager
+  const knex = (em as any).getConnection().getKnex()
+  const sourceColumn = config.sourceColumn ?? 'id'
+  const tenantColumn = config.tenantColumn ?? 'tenant_id'
+  const organizationColumn = config.organizationColumn ?? 'organization_id'
+
+  let mapQuery = knex(config.table)
+    .select(config.targetColumn)
+    .whereIn(sourceColumn, ids)
+
+  if (ctx.auth?.tenantId !== undefined) {
+    mapQuery = mapQuery.whereRaw('?? is not distinct from ?', [tenantColumn, ctx.auth?.tenantId ?? null])
+  }
+  if (ctx.selectedOrganizationId) {
+    mapQuery = mapQuery.where(organizationColumn, ctx.selectedOrganizationId)
+  } else if (Array.isArray(ctx.organizationIds) && ctx.organizationIds.length > 0) {
+    mapQuery = mapQuery.whereIn(organizationColumn, ctx.organizationIds)
+  }
+
+  const rows = await mapQuery
+  return rows
+    .map((row: Record<string, unknown>) => {
+      const value = row[config.targetColumn]
+      return typeof value === 'string' ? value : null
+    })
+    .filter((id: string | null): id is string => typeof id === 'string' && id.length > 0)
+}
+
+export async function findMatchingEntityIdsBySearchTokensAcrossSources({
+  ctx,
+  sources,
+  query,
+}: {
+  ctx: CrudCtx
+  sources: SearchTokenSource[]
+  query: string
+}): Promise<string[] | null> {
+  const trimmed = query.trim()
+  if (!trimmed) return null
+
+  const enrichedSources = await enrichSearchSourcesWithCustomFieldTokens(ctx, sources)
+  const matchedIds = new Set<string>()
+  for (const source of enrichedSources) {
+    const rawIds = await findSearchTokenEntityIds({
+      ctx,
+      entityType: source.entityType,
+      fields: source.fields,
+      query: trimmed,
+    })
+    if (rawIds === null) return null
+    const entityIds = source.mapToEntityIds
+      ? await mapScopedEntityIds({ ctx, ids: rawIds, config: source.mapToEntityIds })
+      : rawIds
+    entityIds.forEach((id) => matchedIds.add(id))
+  }
+
+  return Array.from(matchedIds)
+}
+
+export async function findMatchingEntityIdsBySearchTokens({
+  ctx,
+  entityType,
+  fields,
+  query,
+}: SearchTokenMatchInput): Promise<string[] | null> {
+  return findMatchingEntityIdsBySearchTokensAcrossSources({
+    ctx,
+    query,
+    sources: [{ entityType, fields }],
+  })
+}
+
+export function applyEntityIdRestriction(
+  filters: Record<string, unknown>,
+  ids: string[] | null,
+): void {
+  if (ids === null) return
+  const currentIdFilter =
+    filters.id && typeof filters.id === 'object' && !Array.isArray(filters.id)
+      ? (filters.id as { $eq?: unknown; $in?: unknown })
+      : null
+  const currentEq = typeof currentIdFilter?.$eq === 'string' ? currentIdFilter.$eq : null
+
+  if (currentEq) {
+    filters.id = ids.includes(currentEq) ? { $eq: currentEq } : { $eq: NO_MATCH_ID }
+    return
+  }
+
+  filters.id = ids.length > 0 ? { $in: ids } : { $eq: NO_MATCH_ID }
+}
+
+export function consumeAdvancedFilterState(query: Record<string, unknown>) {
+  const state = deserializeAdvancedFilter(query)
+  if (!state) return null
+
+  for (const key of Object.keys(query)) {
+    if (key.startsWith('filter[')) {
+      delete query[key]
+    }
+  }
+
+  return state
+}
+
+export async function findMatchingEntityIdsWithQueryEngine({
+  ctx,
+  entityId,
+  filters,
+  customFieldSources,
+  joins,
+}: {
+  ctx: CrudCtx
+  entityId: EntityId
+  filters: Record<string, unknown>
+  customFieldSources?: QueryCustomFieldSource[]
+  joins?: QueryJoinEdge[]
+}): Promise<string[]> {
+  const qe = ctx.container.resolve('queryEngine') as QueryEngine
+  const ids = new Set<string>()
+  const pageSize = 100
+  let page = 1
+  let total = 0
+
+  do {
+    const result = await qe.query(entityId, {
+      fields: ['id'],
+      filters,
+      page: { page, pageSize },
+      sort: [{ field: 'id', dir: SortDir.Asc }],
+      tenantId: ctx.auth?.tenantId ?? undefined,
+      organizationId: ctx.selectedOrganizationId ?? undefined,
+      organizationIds: ctx.organizationIds ?? undefined,
+      customFieldSources,
+      joins,
+    })
+
+    total = result.total ?? 0
+    for (const item of result.items ?? []) {
+      const id = item && typeof item === 'object' ? (item as Record<string, unknown>).id : null
+      if (typeof id === 'string' && id.length > 0) {
+        ids.add(id)
+      }
+    }
+    if (!result.items?.length) break
+    page += 1
+  } while (ids.size < total)
+
+  return Array.from(ids)
+}
+
 export { withScopedPayload, parseScopedCommandInput }

package/src/modules/customers/backend/customers/companies/page.tsx

@@ -17,6 +17,8 @@ import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
 import type { FilterDef, FilterValues } from '@open-mercato/ui/backend/FilterBar'
 import type { FilterOption } from '@open-mercato/ui/backend/FilterOverlay'
+import type { AdvancedFilterState } from '@open-mercato/shared/lib/query/advanced-filter'
+import { serializeAdvancedFilter } from '@open-mercato/shared/lib/query/advanced-filter'
 import {
   DictionaryValue,
   renderDictionaryColor,
@@ -26,8 +28,12 @@ import {
 } from '../../../lib/dictionaries'
 import {
   useCustomFieldDefs,
-  filterCustomFieldDefs,
 } from '@open-mercato/ui/backend/utils/customFieldDefs'
+import {
+  mapCustomFieldKindToFilterType,
+  normalizeCustomFieldFilterOptions,
+  supportsCustomFieldColumn,
+} from '@open-mercato/ui/backend/utils/customFieldColumns'
 import { useQueryClient } from '@tanstack/react-query'
 import { ensureCustomerDictionary } from '../../../components/detail/hooks/useCustomerDictionary'
 
@@ -37,6 +43,13 @@ type CompanyRow = {
   description?: string | null
   email?: string | null
   phone?: string | null
+  legalName?: string | null
+  brandName?: string | null
+  domain?: string | null
+  websiteUrl?: string | null
+  industry?: string | null
+  sizeBucket?: string | null
+  annualRevenue?: string | null
   status?: string | null
   lifecycleStage?: string | null
   nextInteractionAt?: string | null
@@ -71,6 +84,18 @@ function mapApiItem(item: Record<string, unknown>): CompanyRow | null {
   const description = typeof item.description === 'string' ? item.description : null
   const email = typeof item.primary_email === 'string' ? item.primary_email : null
   const phone = typeof item.primary_phone === 'string' ? item.primary_phone : null
+  const legalName = typeof item.legal_name === 'string' ? item.legal_name : null
+  const brandName = typeof item.brand_name === 'string' ? item.brand_name : null
+  const domain = typeof item.domain === 'string' ? item.domain : null
+  const websiteUrl = typeof item.website_url === 'string' ? item.website_url : null
+  const industry = typeof item.industry === 'string' ? item.industry : null
+  const sizeBucket = typeof item.size_bucket === 'string' ? item.size_bucket : null
+  const annualRevenue =
+    typeof item.annual_revenue === 'string'
+      ? item.annual_revenue
+      : typeof item.annual_revenue === 'number'
+        ? String(item.annual_revenue)
+        : null
   const status = typeof item.status === 'string' ? item.status : null
   const lifecycleStage = typeof item.lifecycle_stage === 'string' ? item.lifecycle_stage : null
   const nextInteractionAt = typeof item.next_interaction_at === 'string' ? item.next_interaction_at : null
@@ -91,6 +116,13 @@ function mapApiItem(item: Record<string, unknown>): CompanyRow | null {
     description,
     email,
     phone,
+    legalName,
+    brandName,
+    domain,
+    websiteUrl,
+    industry,
+    sizeBucket,
+    annualRevenue,
     status,
     lifecycleStage,
     nextInteractionAt,
@@ -107,11 +139,13 @@ export default function CustomersCompaniesPage() {
   const { confirm, ConfirmDialogElement } = useConfirmDialog()
   const [rows, setRows] = React.useState<CompanyRow[]>([])
   const [page, setPage] = React.useState(1)
-  const [pageSize] = React.useState(20)
+  const [pageSize, setPageSize] = React.useState(20)
+  const [sorting, setSorting] = React.useState<import('@tanstack/react-table').SortingState>([])
   const [total, setTotal] = React.useState(0)
   const [totalPages, setTotalPages] = React.useState(1)
   const [search, setSearch] = React.useState('')
   const [filterValues, setFilterValues] = React.useState<FilterValues>({})
+  const [advancedFilterState, setAdvancedFilterState] = React.useState<AdvancedFilterState>({ logic: 'and', conditions: [] })
   const [isLoading, setIsLoading] = React.useState(true)
   const [reloadToken, setReloadToken] = React.useState(0)
   const [cacheStatus, setCacheStatus] = React.useState<'hit' | 'miss' | null>(null)
@@ -131,6 +165,10 @@ export default function CustomersCompaniesPage() {
   const queryClient = useQueryClient()
   const t = useT()
   const router = useRouter()
+  const handlePageSizeChange = React.useCallback((newSize: number) => {
+    setPageSize(newSize)
+    setPage(1)
+  }, [])
   const fetchDictionaryEntries = React.useCallback(async (kind: DictionaryKindKey) => {
     try {
       const data = await ensureCustomerDictionary(queryClient, kind, scopeVersion)
@@ -299,6 +337,10 @@ export default function CustomersCompaniesPage() {
     const params = new URLSearchParams()
     params.set('page', String(page))
     params.set('pageSize', String(pageSize))
+    if (sorting.length > 0) {
+      params.set('sort', sorting[0].id)
+      params.set('order', sorting[0].desc ? 'desc' : 'asc')
+    }
     if (search.trim()) params.set('search', search.trim())
     const status = filterValues.status
     if (typeof status === 'string' && status.trim()) params.set('status', status)
@@ -358,8 +400,12 @@ export default function CustomersCompaniesPage() {
         if (stringValue) params.set(key, stringValue)
       }
     })
+    const advancedParams = serializeAdvancedFilter(advancedFilterState)
+    for (const [key, val] of Object.entries(advancedParams)) {
+      params.set(key, val)
+    }
     return params.toString()
-  }, [filterValues, page, pageSize, search, tagIdToLabel, tagLabelToId])
+  }, [advancedFilterState, filterValues, page, pageSize, search, sorting, tagIdToLabel, tagLabelToId])
 
   const currentParams = React.useMemo(() => Object.fromEntries(new URLSearchParams(queryParams)), [queryParams])
   const exportConfig = React.useMemo(() => ({
@@ -439,6 +485,35 @@ export default function CustomersCompaniesPage() {
     }
   }, [confirm, handleRefresh, t])
 
+  const handleBulkDelete = React.useCallback(async (selectedRows: CompanyRow[]) => {
+    const confirmed = await confirm({
+      title: t('customers.companies.list.bulkDelete.title', 'Delete {count} companies?', { count: selectedRows.length }),
+      description: t('customers.companies.list.bulkDelete.description', 'This action cannot be undone.'),
+      variant: 'destructive',
+    })
+    if (!confirmed) return false
+    let deletedCount = 0
+    for (const row of selectedRows) {
+      try {
+        await apiCallOrThrow(`/api/customers/companies?id=${encodeURIComponent(row.id)}`, {
+          method: 'DELETE',
+          headers: { 'content-type': 'application/json' },
+        })
+        deletedCount++
+      } catch {}
+    }
+    if (deletedCount > 0) {
+      setRows((prev) => {
+        const deletedIds = new Set(selectedRows.map((r) => r.id))
+        return prev.filter((r) => !deletedIds.has(r.id))
+      })
+      setTotal((prev) => Math.max(0, prev - deletedCount))
+      flash(t('customers.companies.list.bulkDelete.success', '{count} companies deleted', { count: deletedCount }), 'success')
+      setReloadToken((prev) => prev + 1)
+    }
+    return deletedCount > 0
+  }, [confirm, t])
+
   const handleFiltersApply = React.useCallback((values: FilterValues) => {
     const next: FilterValues = {}
     Object.entries(values).forEach(([key, value]) => {
@@ -509,6 +584,7 @@ export default function CustomersCompaniesPage() {
       {
         accessorKey: 'name',
         header: t('customers.companies.list.columns.name'),
+        meta: { alwaysVisible: true, columnChooserGroup: 'Basic Info', filterKey: 'display_name' },
         cell: ({ row }) => (
           <Link href={`/backend/customers/companies-v2/${row.original.id}`} className="font-medium hover:underline">
             {row.original.name}
@@ -518,21 +594,36 @@ export default function CustomersCompaniesPage() {
       {
         accessorKey: 'email',
         header: t('customers.companies.list.columns.email'),
+        meta: { columnChooserGroup: 'Contact', filterKey: 'primary_email' },
         cell: ({ row }) => row.original.email || noValue,
       },
+      {
+        accessorKey: 'phone',
+        header: t('customers.companies.detail.highlights.primaryPhone', 'Primary phone'),
+        meta: { columnChooserGroup: 'Contact', hidden: true, filterKey: 'primary_phone' },
+        cell: ({ row }) => row.original.phone || noValue,
+      },
       {
         accessorKey: 'status',
         header: t('customers.companies.list.columns.status'),
+        meta: { filterType: 'select' as const, filterOptions: dictionaryOptions.statuses, columnChooserGroup: 'Basic Info' },
         cell: ({ row }) => renderDictionaryCell('statuses', row.original.status),
       },
       {
         accessorKey: 'lifecycleStage',
         header: t('customers.companies.list.columns.lifecycleStage'),
+        meta: {
+          filterType: 'select' as const,
+          filterOptions: dictionaryOptions.lifecycleStages,
+          columnChooserGroup: 'Basic Info',
+          filterKey: 'lifecycle_stage',
+        },
         cell: ({ row }) => renderDictionaryCell('lifecycle-stages', row.original.lifecycleStage),
       },
       {
         accessorKey: 'nextInteractionAt',
         header: t('customers.companies.list.columns.nextInteraction'),
+        meta: { columnChooserGroup: 'Dates', filterKey: 'next_interaction_at' },
         cell: ({ row }) =>
           row.original.nextInteractionAt
             ? (
@@ -560,15 +651,78 @@ export default function CustomersCompaniesPage() {
       {
         accessorKey: 'source',
         header: t('customers.companies.list.columns.source'),
+        meta: { filterType: 'select' as const, filterOptions: dictionaryOptions.sources, columnChooserGroup: 'Basic Info' },
         cell: ({ row }) => renderDictionaryCell('sources', row.original.source),
       },
+      {
+        accessorKey: 'legalName',
+        header: t('customers.companies.detail.fields.legalName', 'Legal name'),
+        meta: { columnChooserGroup: 'Profile', hidden: true, filterKey: 'company_profile.legal_name' },
+        cell: ({ row }) => row.original.legalName || noValue,
+      },
+      {
+        accessorKey: 'brandName',
+        header: t('customers.companies.detail.fields.brandName', 'Brand name'),
+        meta: { columnChooserGroup: 'Profile', hidden: true, filterKey: 'company_profile.brand_name' },
+        cell: ({ row }) => row.original.brandName || noValue,
+      },
+      {
+        accessorKey: 'domain',
+        header: t('customers.companies.detail.fields.domain', 'Domain'),
+        meta: { columnChooserGroup: 'Profile', hidden: true, filterKey: 'company_profile.domain' },
+        cell: ({ row }) => row.original.domain || noValue,
+      },
+      {
+        accessorKey: 'websiteUrl',
+        header: t('customers.companies.detail.fields.website', 'Website'),
+        meta: { columnChooserGroup: 'Profile', hidden: true, filterKey: 'company_profile.website_url' },
+        cell: ({ row }) => row.original.websiteUrl || noValue,
+      },
+      {
+        accessorKey: 'industry',
+        header: t('customers.companies.detail.fields.industry', 'Industry'),
+        meta: { columnChooserGroup: 'Profile', hidden: true, filterKey: 'company_profile.industry' },
+        cell: ({ row }) => row.original.industry || noValue,
+      },
+      {
+        accessorKey: 'sizeBucket',
+        header: t('customers.companies.detail.fields.sizeBucket', 'Company size'),
+        meta: { columnChooserGroup: 'Profile', hidden: true, filterKey: 'company_profile.size_bucket' },
+        cell: ({ row }) => row.original.sizeBucket || noValue,
+      },
+      {
+        accessorKey: 'annualRevenue',
+        header: t('customers.companies.detail.highlights.annualRevenue', 'Annual revenue'),
+        meta: {
+          columnChooserGroup: 'Profile',
+          hidden: true,
+          filterKey: 'company_profile.annual_revenue',
+          filterType: 'number' as const,
+        },
+        cell: ({ row }) => row.original.annualRevenue || noValue,
+      },
+      {
+        accessorKey: 'description',
+        header: t('customers.companies.detail.fields.description', 'Description'),
+        meta: { columnChooserGroup: 'Notes', hidden: true, filterKey: 'description' },
+        cell: ({ row }) => row.original.description || noValue,
+      },
     ]
 
-    const customColumns = filterCustomFieldDefs(customFieldDefs, 'list').map<ColumnDef<CompanyRow>>((def) => ({
-      accessorKey: `cf_${def.key}`,
-      header: def.label || def.key,
-      cell: ({ getValue }) => renderCustomFieldCell(getValue()),
-    }))
+    const customColumns = customFieldDefs
+      .filter((def) => supportsCustomFieldColumn(def))
+      .map<ColumnDef<CompanyRow>>((def) => ({
+        accessorKey: `cf_${def.key}`,
+        header: def.label || def.key,
+        meta: {
+          columnChooserGroup: def.group?.title ?? 'Custom Fields',
+          filterGroup: def.group?.title ?? 'Custom Fields',
+          filterType: mapCustomFieldKindToFilterType(def.kind),
+          filterOptions: normalizeCustomFieldFilterOptions(def.options),
+          hidden: def.listVisible === false,
+        },
+        cell: ({ getValue }) => renderCustomFieldCell(getValue()),
+      }))
 
     return [...baseColumns, ...customColumns]
   }, [customFieldDefs, dictionaryMaps, t])
@@ -577,6 +731,7 @@ export default function CustomersCompaniesPage() {
     <Page>
       <PageBody>
         <DataTable<CompanyRow>
+          stickyFirstColumn
           title={t('customers.companies.list.title')}
           refreshButton={{
             label: t('customers.companies.list.actions.refresh'),
@@ -590,6 +745,7 @@ export default function CustomersCompaniesPage() {
             </Button>
           )}
           columns={columns}
+          columnChooser={{ auto: true }}
           data={rows}
           exporter={exportConfig}
           searchValue={search}
@@ -602,6 +758,17 @@ export default function CustomersCompaniesPage() {
           entityIds={[E.customers.customer_entity, E.customers.customer_company_profile]}
           onRowClick={(row) => router.push(`/backend/customers/companies-v2/${row.id}`)}
           perspective={{ tableId: 'customers.companies.list' }}
+          sortable
+          sorting={sorting}
+          onSortingChange={setSorting}
+          bulkActions={[
+            {
+              id: 'delete',
+              label: t('customers.companies.list.actions.bulkDelete', 'Delete selected'),
+              destructive: true,
+              onExecute: handleBulkDelete,
+            },
+          ]}
           rowActions={(row) => (
             <RowActions
               items={[
@@ -624,7 +791,15 @@ export default function CustomersCompaniesPage() {
               ]}
             />
           )}
-          pagination={{ page, pageSize, total, totalPages, onPageChange: setPage, cacheStatus }}
+          advancedFilter={{
+              auto: true,
+              value: advancedFilterState,
+              onChange: setAdvancedFilterState,
+              onApply: () => { setPage(1) },
+              onClear: () => { setAdvancedFilterState({ logic: 'and', conditions: [] }); setPage(1) },
+            }}
+          virtualized
+          pagination={{ page, pageSize, total, totalPages, onPageChange: setPage, pageSizeOptions: [10, 25, 50, 100], onPageSizeChange: handlePageSizeChange, cacheStatus }}
           isLoading={isLoading}
         />
       </PageBody>