@kodeme-io/next-core-hooks v2.0 🚀

Enterprise-grade React hooks for Next.js + Odoo development with React Query-level features, real-time capabilities, and comprehensive developer tools.

> 🎯 What's New in v2.0?
> - ✅ React Query-level data fetching with background refetch, infinite scroll, optimistic updates
> - ✅ Complete Odoo integration with useOdooModel, useOdooForm, useOdooWorkflow
> - ✅ Real-time subscriptions and polling for live updates
> - ✅ Advanced relational field management (Many2one, One2many, Attachments)
> - ✅ Developer experience tools with debugging and performance monitoring
> - ✅ TypeScript-first design with 100% type coverage
> - ✅ SSR-safe production hooks with hydration safety

Installation

``bash
npm install @kodeme-io/next-core-hooks


or

`tsx
import {
useOdooModel,
useOdooForm,
useQueryV2 as useQuery,
useMany2one
} from '@kodeme-io/next-core-hooks'

// 📊 Enhanced data fetching with React Query-level features
const { data, loading, error, refetch } = useQuery(
['orders', 'sale'],
() => dataClient.search(Models.SaleOrder, { where: { state: 'sale' } }),
{
staleTime: 300000,
refetchOnWindowFocus: true,
suspense: true
}
)

// 🏢 Complete Odoo model interaction
const customers = useOdooModel('res.partner', {
fields: ['name', 'email', 'phone'],
domain: [['is_company', '=', true]],
order: 'name ASC'
})

// 📝 Advanced form state management
const customerForm = useOdooForm('res.partner', customerId, {
fields: ['name', 'email', 'phone', 'is_company'],
autoSave: { enabled: true, debounce: 2000 },
onSubmit: async (values) => {
await customers.update(customerId, values)
toast.success('Customer saved!')
}
})

// 🔗 Relational field management
const partnerField = useMany2one('res.partner', {
value: customerForm.values.partner_id,
onChange: (partner) => customerForm.setValue('partner_id', partner?.[0]),
domain: [['is_company', '=', true]],
placeholder: 'Select customer...'
})
`

---

📚 API Documentation

$3

#### useQuery - React Query-level features

`tsx
import { useQuery, useInfiniteQuery } from '@kodeme-io/next-core-hooks'

// Basic query with advanced features
const { data, loading, error, refetch, isStale, isFetching } = useQuery(
['orders', 'sale'], // cache key
() => dataClient.search(Models.SaleOrder, { where: { state: 'sale' } }),
{
staleTime: 300000, // 5 minutes
refetchOnWindowFocus: true, // Background refetch
refetchOnReconnect: true, // Refetch on reconnect
suspense: true, // Suspense mode
select: (data) => data.filter(order => order.amount_total > 1000),
placeholderData: []
}
)

// Infinite query for pagination
const {
data,
fetchNextPage,
hasNextPage,
isFetchingNextPage
} = useInfiniteQuery(
['customers'],
({ pageParam = 0 }) => fetchCustomers(pageParam, 20),
{
getNextPageParam: (lastPage, allPages) =>
lastPage.length === 20 ? allPages.length : undefined
}
)

// Access all customers data
const allCustomers = data.pages.flat()
`

#### QueryClient - Advanced cache management

`tsx
import { QueryClient, queryClient } from '@kodeme-io/next-core-hooks'

// Global cache operations
queryClient.invalidateQueries(['orders'])
queryClient.setQueryData(['customers'], updatedCustomers)
const cachedData = queryClient.getQueryData(['orders'])

// Create client instance for specific contexts
const client = new QueryClient()
`

$3

#### useOdooModel - Complete CRUD + metadata

`tsx
import { useOdooModel } from '@kodeme-io/next-core-hooks'

const customers = useOdooModel('res.partner', {
fields: ['name', 'email', 'phone', 'is_company', 'country_id'],
domain: [['is_company', '=', true]],
order: 'name ASC',
limit: 20,
loadFields: true, // Load field metadata
loadViews: true // Load view definitions
})

// CRUD operations
const handleCreate = async () => {
const id = await customers.create({
name: 'New Customer',
email: 'customer@example.com',
is_company: true
})
}

const handleUpdate = async (id: number) => {
await customers.update(id, { name: 'Updated Name' })
}

const handleDelete = async (id: number) => {
await customers.delete(id)
}

// Advanced operations
const searchResults = await customers.nameSearch('ABC', [['is_company', '=', true]])
const groups = await customers.readGroup(
[['is_company', '=', true]],
['country_id'],
['country_id']
)

// Method calls
const result = await customers.call('compute_total', [123], { context: {} })

// Field metadata
const nameField = customers.fields.name
console.log(nameField.required, nameField.type, nameField.string)
`

#### useOdooModels - Multiple models

`tsx
const models = useOdooModels({
customers: { model: 'res.partner', options: { domain: [['is_company', '=', true]] } },
orders: { model: 'sale.order', options: { domain: [['state', '=', 'sale']] } },
products: { model: 'product.product', options: { domain: [['sale_ok', '=', true]] } }
})

// Access each model
const { data: customers, loading: customersLoading } = models.customers
const { data: orders, create: createOrder } = models.orders
const { data: products, fields: productFields } = models.products
`

$3

#### useOdooForm - Advanced form state

`tsx
import { useOdooForm } from '@kodeme-io/next-core-hooks'

const customerForm = useOdooForm('res.partner', customerId, {
fields: ['name', 'email', 'phone', 'is_company', 'country_id'],
initialValues: { is_company: true },
autoSave: {
enabled: true,
debounce: 2000,
validateBeforeSave: true
},
validation: {
validateOnChange: true,
validateOnBlur: true,
stopValidationOnFirstError: false
},
onSubmit: async (values, { mode }) => {
if (mode === 'create') {
const id = await customers.create(values)
router.push(/customers/${id})
} else {
await customers.update(customerId, values)
}
},
onDirty: (dirty) => setHasUnsavedChanges(dirty),
dependencies: {
country_id: (values) => {
// Compute country-specific validation
return values.country_id ? { country_required: true } : {}
}
}
})

return (


#### useOdooWorkflow - Workflow state and transitions

`tsx
import { useOdooWorkflow } from '@kodeme-io/next-core-hooks'

const orderWorkflow = useOdooWorkflow('sale.order', orderId, {
refreshInterval: 30000,
onStateChange: (newState) => {
toast.info(Order moved to ${newState})
},
onTransitionSuccess: (transition) => {
console.log('Transition executed:', transition)
}
})

return (


#### useOdooSubscription - Real-time updates

`tsx
import { useOdooSubscription } from '@kodeme-io/next-core-hooks'

const subscription = useOdooSubscription('sale.order', {
domain: [['state', '=', 'sale']],
onCreate: (record) => {
toast.success(New order ${record.name} created!)
// Refresh orders list
refetchOrders()
},
onUpdate: (record) => {
console.log('Order updated:', record)
// Update local state
updateOrderInList(record)
},
onDelete: (id) => {
toast.info('Order deleted')
// Remove from local state
removeOrderFromList(id)
},
autoConnect: true,
reconnectAttempts: 3
})

return (


#### useOdooPolling - Change monitoring

`tsx
import { useOdooPolling } from '@kodeme-io/next-core-hooks'

const poller = useOdooPolling('res.partner', customerId, {
interval: 5000,
fields: ['name', 'email', 'phone', 'last_update'],
onChange: (record) => {
if (record.last_update !== lastUpdate) {
setCustomer(record)
setLastUpdate(record.last_update)
}
},
onError: (error) => {
console.error('Polling error:', error)
},
onlyWhenVisible: true
})
`

$3

#### useMany2one - Many2one field management

`tsx
import { useMany2one } from '@kodeme-io/next-core-hooks'

const partnerField = useMany2one('res.partner', {
value: order.partner_id,
onChange: (partner) => {
updateOrder(prev => ({ ...prev, partner_id: partner?.[0] }))
},
domain: [['is_company', '=', true]],
fields: ['name', 'email', 'phone'],
placeholder: 'Select customer...',
searchable: true,
clearable: true,
create: true,
onCreate: async (name) => {
// Quick create new customer
const id = await customers.create({ name, is_company: true })
return [id, name]
}
})

return (