FilterCriteria

type FilterCriteria<T> = Partial<Record<keyof T, FilterCondition>> & FilterMetadata<T>

type FilterOperator =
  | 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte'
  | 'like' | 'ilike'
  | 'in' | 'is' | 'not'
  | 'between'
  | 'cs' | 'cd' | 'sl' | 'sr' | 'nxl' | 'nxr' | 'adj'
  | 'fts' | 'plfts' | 'phfts'

interface FilterCondition {
  operator: FilterOperator
  value: FilterValue | FilterArrayValue
}

type FilterValue = string | number | boolean | Date | null
type FilterArrayValue = (string | number | boolean | Date)[]

const eq: FilterCondition = { operator: 'eq', value: 'active' }
const range: FilterCondition = { operator: 'between', value: [10, 100] }
const inList: FilterCondition = { operator: 'in', value: ['draft', 'pending'] }
const search: FilterCondition = { operator: 'fts', value: 'typescript' }

interface OrConditionGroup<T> {
  or: {
    field: keyof T
    condition: FilterCondition
  }[]
}

interface User { id: number; status: string; role: string }

const orGroup: OrConditionGroup<User> = {
  or: [
    { field: 'status', condition: { operator: 'eq', value: 'active' } },
    { field: 'role', condition: { operator: 'eq', value: 'admin' } },
  ],
}

interface PaginationOptions {
  limit: number
  offset?: number   // offset-based
  cursor?: string   // cursor-based (alternativa per dataset grandi)
}

// Prima pagina di 20
const p1: PaginationOptions = { limit: 20, offset: 0 }

// Seconda pagina
const p2: PaginationOptions = { limit: 20, offset: 20 }

// Cursor-based (performance costanti)
const cursor: PaginationOptions = { limit: 50, cursor: 'eyJpZCI6MTAwfQ==' }

interface SortOptions<T> {
  field: keyof T | string
  direction: 'asc' | 'desc'
  nullsFirst?: boolean
  recursive?: boolean // ordinamento su relazioni embedded
}

interface VerticalFilterOptions {
  select?: string[]
  embed?: Record<string, unknown>
}

// Selezione campi
const select: VerticalFilterOptions = { select: ['id', 'name', 'email'] }

// Con embedding di relazioni FK
const withRelations: VerticalFilterOptions = {
  select: ['id', 'title', 'content'],
  embed: {
    author: { select: ['name', 'avatar'] },
    comments: { select: ['text', 'createdAt'], limit: 10 },
  },
}

// Inner join
const innerJoin: VerticalFilterOptions = {
  select: ['*'],
  embed: { 'profile!inner': {} },
}

interface FilterMetadata<T> {
  orConditions?: OrConditionGroup<T>[]
  sort?: SortOptions<T>[] | SortOptions<T>
  pagination?: PaginationOptions
  vertical?: VerticalFilterOptions
}

function createFilterFromMetadata<T>(metadata: MetadataOnlyFilter<T>): FilterCriteria<T>

import { createFilterFromMetadata } from '@pzeta/postgrest'

const metadata = {
  sort: { field: 'createdAt', direction: 'desc' as const },
  pagination: { limit: 10 },
}

const filter = createFilterFromMetadata<User>(metadata)
const users = await userRepo.readAll(filter)

const isValidFilterOperator = (operator: string): operator is FilterOperator

const userInput = 'eq'

if (isValidFilterOperator(userInput)) {
  // userInput è ora tipizzato come FilterOperator
  const condition: FilterCondition = { operator: userInput, value: 'active' }
}

const isValidFilterValue = (value: unknown): value is FilterValue | FilterArrayValue

isValidFilterValue('active')        // true
isValidFilterValue(42)              // true
isValidFilterValue(new Date())      // true
isValidFilterValue(null)            // true
isValidFilterValue(['a', 'b'])      // true
isValidFilterValue({ key: 'v' })    // false
isValidFilterValue(undefined)       // false

const formatSortOption = <T>(option: SortOptions<T>): string

formatSortOption({ field: 'name', direction: 'asc' })
// "name.asc"

formatSortOption({ field: 'price', direction: 'desc', nullsFirst: false })
// "price.desc.nullslast"

formatSortOption({ field: 'updatedAt', direction: 'desc', nullsFirst: true })
// "updatedAt.desc.nullsfirst"

const buildVerticalSelect = (options?: VerticalFilterOptions): string | undefined

buildVerticalSelect({ select: ['id', 'name', 'email'] })
// "id,name,email"

buildVerticalSelect({
  select: ['id', 'title'],
  embed: { author: { select: ['name'] }, comments: {} },
})
// 'id,title,author({"select":["name"]}),comments'

buildVerticalSelect()  // undefined
buildVerticalSelect({}) // undefined

import type { FilterCriteria } from '@pzeta/postgrest'

interface User {
  id: number
  name: string
  email: string
  age: number
  status: string
  createdAt: Date
}

const filter: FilterCriteria<User> = {
  // Filtri sui campi (AND implicito)
  status: { operator: 'eq', value: 'active' },
  age: { operator: 'gte', value: 18 },
  name: { operator: 'ilike', value: '%mario%' },

  // OR conditions
  orConditions: [{
    or: [
      { field: 'email', condition: { operator: 'ilike', value: '%@gmail.com' } },
      { field: 'email', condition: { operator: 'ilike', value: '%@pzeta.it' } },
    ],
  }],

  // Sort multiplo
  sort: [
    { field: 'createdAt', direction: 'desc' },
    { field: 'name', direction: 'asc' },
  ],

  // Paginazione
  pagination: { limit: 20, offset: 0 },

  // Selezione campi
  vertical: {
    select: ['id', 'name', 'email', 'status'],
  },
}

const users = await userRepo.readAll(filter)

interface User {
  id: number
  name: string
  metadata: object  // ❌ non filtrabile
  tags: string[]
}

type Filterable = FilterableFields<User>
// 'id' | 'name' | 'tags'