client.from(collection).find(options)

{
  limit?: number          // 한 페이지당 항목 수 (기본값: 10)
  page?: number           // 페이지 번호 (기본값: 1)
  sort?: string           // 정렬 ('-createdAt', 'price' 등)
  where?: WhereQuery      // 필터 조건
}

Promise<{
  data?: {
    docs: T[]
    pagination: {
      totalDocs: number
      limit: number
      page: number
      totalPages: number
      hasNextPage: boolean
      hasPrevPage: boolean
      nextPage: number | null
      prevPage: number | null
    }
  }
  error?: SDKError
}>

const { data } = await client.from('products').find({
  limit: 20,
  page: 1,
  sort: '-createdAt',
  where: {
    status: { equals: 'published' },
    price: { greater_than: 1000 }
  }
})

client.from(collection).findById(id)

Promise<{
  data?: T
  error?: SDKError
}>

const { data: product } = await client
  .from('products')
  .findById('product_id')

client.from(collection).create(data)

Promise<{
  data?: T
  error?: SDKError
}>

const { data: newProduct } = await client.from('products').create({
  name: '새 상품',
  price: 10000,
  status: 'draft'
})

client.from(collection).update(id, data)

Promise<{
  data?: T
  error?: SDKError
}>

const { data: updatedProduct } = await client
  .from('products')
  .update('product_id', {
    name: '수정된 상품명',
    price: 15000
  })

client.from(collection).remove(id)

Promise<{
  data?: T
  error?: SDKError
}>

const { data: deletedProduct } = await client
  .from('products')
  .remove('product_id')

client.query.useQuery(params, options)

{
  data?: T[]
  isLoading: boolean
  isFetching: boolean
  error: Error | null
  refetch: () => void
  // ... 기타 TanStack Query 속성
}

const { data, isLoading } = client.query.useQuery({
  collection: 'products',
  options: {
    limit: 10,
    where: { status: { equals: 'published' } }
  }
})

client.query.useSuspenseQuery(params, options)

const { data } = client.query.useSuspenseQuery({
  collection: 'products',
  options: { limit: 10 }
})
// data는 항상 존재 (undefined가 아님)

client.query.useQueryById(params, options)

{
  data?: T | null
  isLoading: boolean
  error: Error | null
  refetch: () => void
}

const { data: product } = client.query.useQueryById({
  collection: 'products',
  id: 'product_123'
})

client.query.useSuspenseQueryById(params, options)

const { data: product } = client.query.useSuspenseQueryById({
  collection: 'products',
  id: 'product_123'
})

client.query.useInfiniteQuery(params, options)

{
  data?: {
    pages: T[][]
    pageParams: number[]
  }
  fetchNextPage: () => void
  hasNextPage: boolean
  isFetchingNextPage: boolean
  isLoading: boolean
}

const {
  data,
  fetchNextPage,
  hasNextPage,
  isFetchingNextPage
} = client.query.useInfiniteQuery({
  collection: 'products',
  pageSize: 20
})

await client.query.prefetchQuery(params, options)

// Server Component
await client.query.prefetchQuery({
  collection: 'products',
  options: { limit: 10 }
})

await client.query.prefetchQueryById(params, options)

await client.query.prefetchQueryById({
  collection: 'products',
  id: 'product_123'
})

// 쿼리 무효화
client.query.invalidateQueries('products')
client.query.invalidateQueries('products', 'list')
client.query.invalidateQueries('products', 'detail')

// 캐시 데이터 가져오기
client.query.getQueryData('products', 'list')
client.query.getQueryData('products', 'detail', '123')

// 캐시 데이터 설정
client.query.setQueryData('products', 'list', data)
client.query.setQueryData('products', 'detail', '123', data)

serverClient.api.createOrder(data)

{
  paymentId: string           // 결제 ID
  orderNumber: string         // 주문 번호
  email: string               // 주문자 이메일
  orderProducts: Array<{      // 주문 상품
    product: string           // 상품 ID
    variant: string           // 옵션 ID
    quantity: number          // 수량
    price: number             // 가격
  }>
  totalAmount: number         // 총 금액
  status?: string             // 주문 상태 (기본: 'pending')
  // ... 기타 필드
}

Promise<Order>

const order = await serverClient.api.createOrder({
  paymentId: 'pay_123',
  orderNumber: generateOrderNumber(),
  email: 'user@example.com',
  orderProducts: [{
    product: 'product_id',
    variant: 'variant_id',
    quantity: 1,
    price: 10000
  }],
  totalAmount: 10000
})

serverClient.api.updateOrder(id, data)

Promise<Order>

await serverClient.api.updateOrder('order_id', {
  status: 'completed',
  deliveryStatus: 'delivered'
})

serverClient.api.updateTransaction(id, data)

Promise<Transaction>

await serverClient.api.updateTransaction('transaction_id', {
  status: 'paid',
  paidAt: new Date().toISOString()
})

{
  equals: value                  // 같음
  not_equals: value              // 같지 않음
  greater_than: value            // 보다 큼
  greater_than_equal: value      // 보다 큼 또는 같음
  less_than: value               // 보다 작음
  less_than_equal: value         // 보다 작음 또는 같음
  like: value                    // LIKE (%, _ 사용 가능)
  contains: value                // 포함 (배열)
  not_contains: value            // 포함하지 않음
  in: [value1, value2, ...]      // IN
  not_in: [value1, value2, ...]  // NOT IN
  exists: boolean                // 존재 여부
}

{
  and: [condition1, condition2, ...]  // AND
  or: [condition1, condition2, ...]   // OR
}

{
  where: {
    and: [
      { status: { equals: 'published' } },
      { price: { greater_than: 1000, less_than: 50000 } },
      {
        or: [
          { category: { equals: 'electronics' } },
          { tags: { contains: 'featured' } }
        ]
      }
    ]
  }
}

interface PaginationInfo {
  totalDocs: number
  limit: number
  page: number
  totalPages: number
  hasNextPage: boolean
  hasPrevPage: boolean
  nextPage: number | null
  prevPage: number | null
}

interface ApiSuccessResponse<T> {
  data: T
  error?: never
}

interface ApiErrorResponse {
  data?: never
  error: SDKError
}

class SDKError extends Error {
  code: string
  statusCode?: number
  userMessage: string
  suggestion: string
  getUserMessage(): string
}

import { isSuccessResponse } from '@01.software/sdk'

const response = await client.from('products').find()

if (isSuccessResponse(response)) {
  console.log(response.data) // 타입: { docs: Product[], pagination: PaginationInfo }
}

import { isErrorResponse } from '@01.software/sdk'

const response = await client.from('products').find()

if (isErrorResponse(response)) {
  console.error(response.error) // 타입: SDKError
}

import { isNetworkError } from '@01.software/sdk'

try {
  await client.from('products').find()
} catch (error) {
  if (isNetworkError(error)) {
    console.error('Network error:', error.getUserMessage())
  }
}