@djangocfg/api 1.0.1

package/src/cfg/contexts/payments/README.md

@@ -0,0 +1,201 @@
+# Payments Contexts
+
+Декомпозированные контексты для модуля Payments.
+
+## Структура
+
+### PaymentsContext
+**Файл:** `PaymentsContext.tsx`  
+**Назначение:** Управление платежами
+
+**API:**
+- `payments: PaginatedPaymentListList` - список платежей (пагинированный)
+- `isLoadingPayments: boolean` - статус загрузки
+- `refreshPayments()` - обновить список
+- `getPayment(id)` - получить конкретный платеж
+- `createPayment(data)` - создать платеж
+- `cancelPayment(id, data)` - отменить платеж
+- `checkPaymentStatus(id, data)` - проверить статус платежа
+
+**Использование:**
+```tsx
+import { PaymentsProvider, usePaymentsContext } from '@djangocfg/api/cfg/contexts';
+
+function PaymentsList() {
+  const { payments, isLoadingPayments, refreshPayments } = usePaymentsContext();
+  // ...
+}
+```
+
+---
+
+### BalancesContext
+**Файл:** `BalancesContext.tsx`  
+**Назначение:** Управление балансами пользователей (read-only)
+
+**API:**
+- `balances: PaginatedUserBalanceList` - список балансов
+- `isLoadingBalances: boolean` - статус загрузки
+- `refreshBalances()` - обновить список
+- `getBalance(id)` - получить конкретный баланс
+- `getBalanceSummary()` - получить сводку по балансу
+
+**Использование:**
+```tsx
+import { BalancesProvider, useBalancesContext } from '@djangocfg/api/cfg/contexts';
+
+function Balance() {
+  const { balances, getBalanceSummary } = useBalancesContext();
+  // ...
+}
+```
+
+---
+
+### CurrenciesContext
+**Файл:** `CurrenciesContext.tsx`  
+**Назначение:** Управление валютами и курсами обмена (read-only)
+
+**API:**
+- `currencies: PaginatedCurrencyListList` - список валют
+- `isLoadingCurrencies: boolean` - статус загрузки
+- `refreshCurrencies()` - обновить список
+- `getCurrency(id)` - получить конкретную валюту
+- `getCurrencyRates(baseCurrency, currencies)` - получить курсы обмена
+
+**Использование:**
+```tsx
+import { CurrenciesProvider, useCurrenciesContext } from '@djangocfg/api/cfg/contexts';
+
+function CurrencySelector() {
+  const { currencies, getCurrencyRates } = useCurrenciesContext();
+  // ...
+}
+```
+
+---
+
+### ApiKeysContext
+**Файл:** `ApiKeysContext.tsx`  
+**Назначение:** Управление API ключами
+
+**API:**
+- `apiKeys: PaginatedAPIKeyListList` - список API ключей
+- `isLoadingApiKeys: boolean` - статус загрузки
+- `refreshApiKeys()` - обновить список
+- `getApiKey(id)` - получить конкретный ключ
+- `createApiKey(data)` - создать ключ
+- `deleteApiKey(id)` - удалить ключ
+
+**Использование:**
+```tsx
+import { ApiKeysProvider, useApiKeysContext } from '@djangocfg/api/cfg/contexts';
+
+function ApiKeysList() {
+  const { apiKeys, createApiKey, deleteApiKey } = useApiKeysContext();
+  // ...
+}
+```
+
+---
+
+### OverviewContext
+**Файл:** `OverviewContext.tsx`  
+**Назначение:** Дашборд и метрики платежной системы (read-only)
+
+**API:**
+- `overview: PaymentsDashboardOverview` - общий обзор
+- `metrics: PaymentsMetrics` - метрики
+- `balanceOverview: BalanceOverview` - обзор баланса
+- `apiKeysOverview: APIKeysOverview` - обзор API ключей
+- `subscriptionOverview: SubscriptionOverview` - обзор подписок
+- `chartData: PaymentsChartResponse` - данные для графиков
+- `recentPayments: PaginatedRecentPaymentList` - последние платежи
+- `recentTransactions: PaginatedRecentTransactionList` - последние транзакции
+- `isLoadingOverview: boolean` - статус загрузки
+- `refreshOverview()` - обновить все данные
+
+**Использование:**
+```tsx
+import { OverviewProvider, useOverviewContext } from '@djangocfg/api/cfg/contexts';
+
+function Dashboard() {
+  const { overview, metrics, chartData } = useOverviewContext();
+  // ...
+}
+```
+
+---
+
+## Композиция провайдеров
+
+Если нужно использовать несколько контекстов:
+
+```tsx
+import { 
+  PaymentsProvider, 
+  BalancesProvider, 
+  OverviewProvider 
+} from '@djangocfg/api/cfg/contexts';
+
+function PaymentsDashboard() {
+  return (
+    <OverviewProvider>
+      <PaymentsProvider>
+        <BalancesProvider>
+          <YourComponent />
+        </BalancesProvider>
+      </PaymentsProvider>
+    </OverviewProvider>
+  );
+}
+```
+
+---
+
+## Миграция со старого PaymentsContext
+
+**Было:**
+```tsx
+import { PaymentsProvider, usePaymentsContext } from '@djangocfg/api/cfg/contexts';
+
+const { payments, balances, apiKeys } = usePaymentsContext();
+```
+
+**Стало:**
+```tsx
+import { 
+  PaymentsProvider, usePaymentsContext,
+  BalancesProvider, useBalancesContext,
+  ApiKeysProvider, useApiKeysContext
+} from '@djangocfg/api/cfg/contexts';
+
+// В разных компонентах или комбинируя:
+const { payments } = usePaymentsContext();
+const { balances } = useBalancesContext();
+const { apiKeys } = useApiKeysContext();
+```
+
+---
+
+## Преимущества декомпозиции
+
+1. **Модульность** - каждый контекст отвечает за свою область
+2. **Производительность** - меньше ненужных ре-рендеров
+3. **Гибкость** - можно использовать только нужные контексты
+4. **Читаемость** - явное разделение зон ответственности
+5. **Масштабируемость** - проще добавлять новую функциональность
+
+---
+
+## Не включенные сущности
+
+В текущей декомпозиции **не включены** (могут быть добавлены позже):
+- `SubscriptionsContext` - управление подписками (CRUD)
+- `TransactionsContext` - история транзакций (read-only)
+- `TariffsContext` - тарифные планы (read-only)
+- `NetworksContext` - блокчейн сети (read-only)
+- `AdminContext` - админ-функции (для админки)
+
+Эти сущности можно добавить по мере необходимости, следуя той же структуре.
+

package/src/cfg/contexts/payments/index.ts

@@ -0,0 +1,65 @@
+// Payments
+export {
+  PaymentsProvider,
+  usePaymentsContext
+} from './PaymentsContext';
+export type {
+  PaymentsContextValue,
+  Payment,
+  PaymentCreate,
+  PaymentCreateRequest,
+  PaymentRequest,
+  PaginatedPaymentListList,
+} from './PaymentsContext';
+
+// Balances
+export {
+  BalancesProvider,
+  useBalancesContext
+} from './BalancesContext';
+export type {
+  BalancesContextValue,
+  UserBalance,
+  PaginatedUserBalanceList,
+} from './BalancesContext';
+
+// Currencies
+export {
+  CurrenciesProvider,
+  useCurrenciesContext
+} from './CurrenciesContext';
+export type {
+  CurrenciesContextValue,
+  Currency,
+  PaginatedCurrencyListList,
+} from './CurrenciesContext';
+
+// API Keys
+export {
+  ApiKeysProvider,
+  useApiKeysContext
+} from './ApiKeysContext';
+export type {
+  ApiKeysContextValue,
+  APIKeyDetail,
+  APIKeyCreateRequest,
+  PaginatedAPIKeyListList,
+} from './ApiKeysContext';
+
+// Overview
+export {
+  OverviewProvider,
+  useOverviewContext
+} from './OverviewContext';
+export type {
+  OverviewContextValue,
+  PaymentsDashboardOverview,
+  PaymentsMetrics,
+  BalanceOverview,
+  APIKeysOverview,
+  SubscriptionOverview,
+  PaymentsChartResponse,
+  PaginatedRecentPaymentList,
+  PaginatedRecentTransactionList,
+} from './OverviewContext';
+

package/src/cfg/generated/_utils/fetchers/cfg__accounts.ts

@@ -0,0 +1,66 @@
+/**
+ * Typed fetchers for Accounts
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { OTPRequestRequestSchema, type OTPRequestRequest } from '../schemas/OTPRequestRequest.schema'
+import { OTPRequestResponseSchema, type OTPRequestResponse } from '../schemas/OTPRequestResponse.schema'
+import { OTPVerifyRequestSchema, type OTPVerifyRequest } from '../schemas/OTPVerifyRequest.schema'
+import { OTPVerifyResponseSchema, type OTPVerifyResponse } from '../schemas/OTPVerifyResponse.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/accounts/otp/request/
+ */
+export async function createAccountsOtpRequestCreate(  data: OTPRequestRequest,  client?: API
+): Promise<OTPRequestResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_accounts.otpRequestCreate(data)
+  return OTPRequestResponseSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/accounts/otp/verify/
+ */
+export async function createAccountsOtpVerifyCreate(  data: OTPVerifyRequest,  client?: API
+): Promise<OTPVerifyResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_accounts.otpVerifyCreate(data)
+  return OTPVerifyResponseSchema.parse(response)
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__accounts__auth.ts

@@ -0,0 +1,50 @@
+/**
+ * Typed fetchers for Auth
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { TokenRefreshSchema, type TokenRefresh } from '../schemas/TokenRefresh.schema'
+import { TokenRefreshRequestSchema, type TokenRefreshRequest } from '../schemas/TokenRefreshRequest.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/accounts/token/refresh/
+ */
+export async function createAccountsTokenRefreshCreate(  data: TokenRefreshRequest,  client?: API
+): Promise<TokenRefresh> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_auth.accountsTokenRefreshCreate(data)
+  return TokenRefreshSchema.parse(response)
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__accounts__user_profile.ts

@@ -0,0 +1,121 @@
+/**
+ * Typed fetchers for User Profile
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { PatchedUserProfileUpdateRequestSchema, type PatchedUserProfileUpdateRequest } from '../schemas/PatchedUserProfileUpdateRequest.schema'
+import { UserSchema, type User } from '../schemas/User.schema'
+import { UserProfileUpdateRequestSchema, type UserProfileUpdateRequest } from '../schemas/UserProfileUpdateRequest.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * Get current user profile
+ *
+ * @method GET
+ * @path /cfg/accounts/profile/
+ */
+export async function getAccountsProfileRetrieve(  client?: API
+): Promise<User> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_user_profile.accountsProfileRetrieve()
+  return UserSchema.parse(response)
+}
+
+
+/**
+ * Upload user avatar
+ *
+ * @method POST
+ * @path /cfg/accounts/profile/avatar/
+ */
+export async function createAccountsProfileAvatarCreate(  data: any,  client?: API
+): Promise<User> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_user_profile.accountsProfileAvatarCreate(data)
+  return UserSchema.parse(response)
+}
+
+
+/**
+ * Partial update user profile
+ *
+ * @method PUT
+ * @path /cfg/accounts/profile/partial/
+ */
+export async function partialUpdateAccountsProfilePartialUpdate(  data: UserProfileUpdateRequest,  client?: API
+): Promise<User> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_user_profile.accountsProfilePartialUpdate(data)
+  return UserSchema.parse(response)
+}
+
+
+/**
+ * Partial update user profile
+ *
+ * @method PATCH
+ * @path /cfg/accounts/profile/partial/
+ */
+export async function partialUpdateAccountsProfilePartialPartialUpdate(  data?: PatchedUserProfileUpdateRequest,  client?: API
+): Promise<User> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_user_profile.accountsProfilePartialPartialUpdate(data)
+  return UserSchema.parse(response)
+}
+
+
+/**
+ * Update user profile
+ *
+ * @method PUT
+ * @path /cfg/accounts/profile/update/
+ */
+export async function updateAccountsProfileUpdateUpdate(  data: UserProfileUpdateRequest,  client?: API
+): Promise<User> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_user_profile.accountsProfileUpdateUpdate(data)
+  return UserSchema.parse(response)
+}
+
+
+/**
+ * Update user profile
+ *
+ * @method PATCH
+ * @path /cfg/accounts/profile/update/
+ */
+export async function partialUpdateAccountsProfileUpdatePartialUpdate(  data?: PatchedUserProfileUpdateRequest,  client?: API
+): Promise<User> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_user_profile.accountsProfileUpdatePartialUpdate(data)
+  return UserSchema.parse(response)
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__endpoints.ts

@@ -0,0 +1,49 @@
+/**
+ * Typed fetchers for Endpoints
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { EndpointsStatusSchema, type EndpointsStatus } from '../schemas/EndpointsStatus.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/endpoints/drf/
+ */
+export async function getEndpointsDrfRetrieve(  client?: API
+): Promise<EndpointsStatus> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_endpoints.drfRetrieve()
+  return EndpointsStatusSchema.parse(response)
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__health.ts

@@ -0,0 +1,64 @@
+/**
+ * Typed fetchers for Health
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { HealthCheckSchema, type HealthCheck } from '../schemas/HealthCheck.schema'
+import { QuickHealthSchema, type QuickHealth } from '../schemas/QuickHealth.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/health/drf/
+ */
+export async function getHealthDrfRetrieve(  client?: API
+): Promise<HealthCheck> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_health.drfRetrieve()
+  return HealthCheckSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/health/drf/quick/
+ */
+export async function getHealthDrfQuickRetrieve(  client?: API
+): Promise<QuickHealth> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_health.drfQuickRetrieve()
+  return QuickHealthSchema.parse(response)
+}
+
+