@classytic/arc-next 0.3.1 → 0.4.1

package/README.md

@@ -30,8 +30,9 @@ import { useRouter } from "next/navigation";
 // Required — sets the API base URL and auth mode
 configureClient({
   baseUrl: process.env.NEXT_PUBLIC_API_URL!,
-  authMode: "cookie",   // 'cookie' for Better Auth, 'bearer' for token auth (default)
-  // credentials: 'omit', // override if you don't want cookies sent cross-origin
+  authMode: "cookie",        // 'cookie' | 'bearer' (default) | 'header'
+  // apiVersion: '2',        // sends Accept-Version header
+  // autoIdempotency: true,  // auto Idempotency-Key on mutations (retry-safe)
 });
 
 // Optional — auto-inject tenant context into queries/mutations
@@ -59,6 +60,7 @@ configureNavigation(useRouter);
 | `@classytic/arc-next/hooks`         | `createCrudHooks`, `configureNavigation`                                     |      Yes        |
 | `@classytic/arc-next/query-client`  | `getQueryClient` (SSR-safe singleton)                                        |       No        |
 | `@classytic/arc-next/prefetch`      | `createCrudPrefetcher`, `dehydrate` (SSR prefetch)                           |       No        |
+| `@classytic/arc-next/sse`           | `useEventStream` (Server-Sent Events for real-time cache invalidation)       |      Yes        |
 
 No barrel index — every file is its own entry point. Tree-shakeable (`sideEffects: false`).
 
@@ -148,25 +150,28 @@ export function ProductsPage() {
 ```ts
 configureClient({
   baseUrl: string;                          // Required — API base URL
-  authMode?: 'cookie' | 'bearer';          // Default: 'bearer'
+  authMode?: 'bearer' | 'cookie' | 'header'; // Default: 'bearer'
   credentials?: RequestCredentials;         // Default: derived from authMode
-  internalApiKey?: string;                  // Optional — sent as x-internal-api-key header
-  defaultHeaders?: Record<string, string>; // Optional — merged into every request
+  internalApiKey?: string;                  // Sent as x-internal-api-key header
+  defaultHeaders?: Record<string, string>; // Merged into every request
+  apiVersion?: string;                     // Sent as Accept-Version header
+  autoIdempotency?: boolean;               // Auto Idempotency-Key on mutations (retry-safe)
 });
 ```
 
-- `authMode: 'bearer'` (default) — requires a token; queries disabled until token provided; `credentials: 'same-origin'`
-- `authMode: 'cookie'` — HTTP-only cookies (e.g. Better Auth); queries always enabled; `credentials: 'include'`
-- `credentials` — explicit override: `'include'` (send cookies cross-origin), `'same-origin'` (same-origin only), `'omit'` (never send cookies)
+- `authMode: 'bearer'` (default) — requires token; queries disabled until provided
+- `authMode: 'cookie'` — HTTP-only cookies (e.g. Better Auth); queries always enabled
+- `authMode: 'header'` — custom header auth (e.g. `x-api-key`); uses `headerName` from `configureAuth`
 
-Must be called before any API requests. Throws if not configured.
+Must be called before any API requests. Warns if called on the server (SSR safety).
 
 ### `configureAuth(config)`
 
 ```ts
 configureAuth({
-  getToken?: () => string | null;   // For bearer auth — return access token
+  getToken?: () => string | null;   // For bearer/header auth — return access token or API key
   getOrgId?: () => string | null;   // Return active organization ID
+  headerName?: string;              // Custom header name for authMode: 'header' (default: 'x-api-key')
 });
 ```
 
@@ -235,12 +240,15 @@ Factory that returns everything you need. The `api` parameter accepts any `creat
 const {
   KEYS, cache,
   useList, useDetail, useInfiniteList,
-  useActions, useUpload, useSearch, useCustomMutation,
+  useActions, useBulkActions,
+  useDeleted, useDetailBySlug, useTree, useChildren, useFindBy,
+  useUpload, useSearch, useCustomMutation,
   useNavigation,
 } = createCrudHooks<Product, CreateProduct>({
     api: productsApi,       // from createCrudApi() — types inferred, no cast
     entityKey: "products",  // TanStack Query key prefix
     singular: "Product",    // for toast messages
+    idField: "sku",         // optional — custom ID field for cache keys (default: _id → id)
     defaults: {             // optional
       staleTime: 60_000,
       messages: { createSuccess: "Product added!" },
@@ -393,27 +401,94 @@ const { mutateAsync: publish, isPending } = useCustomMutation({
 });
 ```
 
+#### `useDeleted(params?, options?)`
+
+List soft-deleted items. Requires `softDelete` preset on the Arc resource.
+
+#### `useDetailBySlug(slug, options?)`
+
+Fetch a single item by slug (`GET /slug/:slug`). Requires `slugLookup` preset.
+
+#### `useTree(params?, options?)`
+
+Fetch hierarchical tree data (`GET /tree`). Requires `tree` preset.
+
+#### `useChildren(parentId, params?, options?)`
+
+Fetch children of a parent node (`GET /:parentId/children`). Requires `tree` preset.
+
+#### `useFindBy(field, value, options?)`
+
+Query by a single field with optional operator:
+
+```ts
+const { items } = useFindBy("status", "active");
+const { items } = useFindBy("price", 50, { operator: "gte" });
+```
+
+#### `useBulkActions()`
+
+```ts
+const { bulkCreate, bulkUpdate, bulkRemove } = useBulkActions();
+await bulkCreate({ data: [{ name: "A" }, { name: "B" }] });
+```
+
+#### `useEventStream(options)` (from `./sse`)
+
+Subscribe to Arc SSE events with auto-reconnect and query invalidation:
+
+```ts
+import { useEventStream } from "@classytic/arc-next/sse";
+
+// Global stream — all events (matches Arc's /events/stream)
+const { isConnected } = useEventStream({
+  invalidateQueries: [agentKeys.lists()],
+});
+
+// Filtered by resource — auto-generates patterns: ['agents.*']
+const { lastEvent } = useEventStream({
+  resource: "agents",
+  invalidateQueries: [agentKeys.lists()],
+});
+
+// Custom SSE path or explicit patterns
+const { isConnected } = useEventStream({
+  path: "/api/v2/events",
+  patterns: ["orders.created", "orders.updated"],
+});
+```
+
 ### Query Keys (`KEYS`)
 
 ```ts
-KEYS.all                          // ["products"]
-KEYS.lists()                      // ["products", "list"]
-KEYS.list(params)                 // ["products", "list", params]
-KEYS.details()                    // ["products", "detail"]
-KEYS.detail(id)                   // ["products", "detail", id]
-KEYS.custom("stats", orgId)       // ["products", "stats", orgId]
-KEYS.scopedList("tenant", params) // ["products", "list", { _scope: "tenant", ...params }]
+KEYS.all                              // ["products"]
+KEYS.lists()                          // ["products", "list"]
+KEYS.list(params)                     // ["products", "list", params]
+KEYS.details()                        // ["products", "detail"]
+KEYS.detail(id)                       // ["products", "detail", id]
+KEYS.scopedDetail(id, orgId)          // ["products", "detail", id, { _org: orgId }] (or bare when null)
+KEYS.custom("stats", orgId)           // ["products", "stats", orgId]
+KEYS.scopedList("tenant", params)     // ["products", "list", { _scope: "tenant", ...params }]
 ```
 
 ### Cache Utilities (`cache`)
 
 ```ts
-await cache.invalidateAll(queryClient);
-await cache.invalidateLists(queryClient);
-await cache.invalidateDetail(queryClient, id);
+// Bare (single-tenant or public)
 cache.setDetail(queryClient, id, data);
-cache.getDetail(queryClient, id);       // T | undefined
+cache.getDetail(queryClient, id);
 cache.removeDetail(queryClient, id);
+await cache.invalidateDetail(queryClient, id);  // prefix-matches ALL scoped variants
+
+// Tenant-scoped (multi-tenant — isolated per org)
+cache.setScopedDetail(queryClient, id, orgId, data);
+cache.getScopedDetail(queryClient, id, orgId);
+cache.removeScopedDetail(queryClient, id, orgId);
+await cache.invalidateScopedDetail(queryClient, id, orgId);
+
+// Global
+await cache.invalidateAll(queryClient);
+await cache.invalidateLists(queryClient);
 ```
 
 ### `getQueryClient(overrides?)`
@@ -467,7 +542,17 @@ export default async function ProductsPage() {
 }
 ```
 
-**Methods:** `prefetchList(queryClient, params?, options?)`, `prefetchDetail(queryClient, id, options?)`
+**Methods:** `prefetchList`, `prefetchDetail`, `prefetchBySlug`, `prefetchDeleted`, `prefetchTree`
+
+All accept auth options for protected routes:
+
+```ts
+await prefetcher.prefetchList(queryClient, { limit: 20 }, {
+  token: serverToken,               // for bearer/header auth
+  organizationId: "org-1",          // for multi-tenant
+  headers: { "x-api-key": apiKey }, // for custom header auth
+});
+```
 
 ## Custom Mutations
 
@@ -566,16 +651,30 @@ By default, `configureClient()` sets a single global `baseUrl`. Use `createClien
 
 ### Create isolated clients
 
+Each client gets its own `baseUrl`, auth, and headers — fully independent from the global config:
+
 ```ts
 import { createClient } from "@classytic/arc-next/client";
-import { toast } from "sonner";
-import { useRouter } from "next/navigation";
 
+// Bearer auth for main API
+const mainClient = createClient({
+  baseUrl: "https://api.example.com",
+  getToken: () => session.jwt,
+  getOrgId: () => currentOrg.id,
+});
+
+// API key auth for analytics (no token needed — hooks auto-enable)
 const analyticsClient = createClient({
-  baseUrl: "https://analytics.example.com",
-  internalApiKey: "analytics-key",
-  toast: { success: toast.success, error: toast.error },
-  navigation: useRouter,
+  baseUrl: "https://analytics.internal",
+  authMode: "header",
+  getToken: () => env.ANALYTICS_KEY,
+  headerName: "x-analytics-key",
+});
+
+// Cookie auth for auth service
+const authClient = createClient({
+  baseUrl: "https://auth.example.com",
+  authMode: "cookie",
 });
 ```
 
@@ -709,12 +808,20 @@ const adminApi = createCrudApi("users", {
 
 - **CRUD Factory** — `createCrudApi` + `createCrudHooks` generates typed API clients and React Query hooks
 - **Optimistic Updates** — Create, update, delete with instant UI feedback and automatic rollback
-- **Multi-Tenant Scoping** — Tenant ID sent via `x-organization-id` header + scoped list query keys. Backend controls the tenant field name and access enforcement.
+- **Multi-Tenant Scoping** — `scopedDetail(id, orgId)` + `scopedList` isolate cache per tenant. Scoped cache utils for reads/writes. Navigation prefill is tenant-aware.
 - **Pagination Normalization** — Handles `docs`/`data`/`items`/`results` + any custom key, offset/keyset/aggregate pagination
 - **Detail Cache Prefilling** — List results auto-populate detail query cache
 - **React 19 Transitions** — `useMutationWithTransition` wraps invalidation in `startTransition`
-- **Cookie & Bearer Auth** — `authMode: 'cookie'` for Better Auth, `'bearer'` for token auth, configurable `credentials` policy
-- **SSR Prefetch** — `createCrudPrefetcher` + `dehydrate` for server component data loading
+- **Cookie, Bearer & Header Auth** — `authMode: 'cookie'` / `'bearer'` / `'header'` (custom header like `x-api-key`)
+- **Custom ID Fields** — `idField` on `createCrudHooks` for resources keyed by `sku`, `slug`, `code`, etc.
+- **Preset Hooks** — `useDeleted`, `useBulkActions`, `useDetailBySlug`, `useTree`, `useChildren`, `useFindBy`
+- **SSE Real-Time** — `useEventStream` with auto-reconnect, auto-pattern derivation from `resource`, query invalidation. Works with zero config or custom `path`.
+- **Infinite Scroll** — `maxPages` for memory management with automatic scroll-back support
+- **Idempotency** — `autoIdempotency` generates retry-safe keys at mutation level
+- **API Versioning** — `apiVersion` sends `Accept-Version` header
+- **SSR Prefetch** — `createCrudPrefetcher` + `prefetchBySlug` / `prefetchDeleted` / `prefetchTree`
+- **SSR Safety** — warns when `configureClient`/`configureAuth` called on the server
+- **Per-Client Auth** — `createClient({ getToken, getOrgId, headerName })` — each backend gets its own auth, queries auto-enable
 - **Multi-Client** — `createClient()` for multiple API backends side by side
 - **Pluggable Toast** — `configureToast()` — use sonner, react-hot-toast, or anything
 - **Pluggable Navigation** — `configureNavigation()` — use Next.js, React Router, or any router

package/dist/api.d.ts

@@ -52,9 +52,22 @@ interface DeleteResponse {
     soft?: boolean;
   };
 }
+interface BulkCreateResponse<T = unknown> {
+  success: boolean;
+  data?: T[];
+  count?: number;
+}
+interface BulkUpdateResponse {
+  success: boolean;
+  modifiedCount?: number;
+}
+interface BulkDeleteResponse {
+  success: boolean;
+  deletedCount?: number;
+}
 type SortDirection = 1 | -1 | 'asc' | 'desc';
 type SortSpec = Record<string, SortDirection> | string;
-type FilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'contains' | 'startsWith' | 'endsWith' | 'regex';
+type FilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'contains' | 'startsWith' | 'endsWith' | 'regex' | 'like' | 'exists' | 'size' | 'type';
 interface QueryParams {
   page?: number;
   limit?: number;
@@ -65,6 +78,13 @@ interface QueryParams {
   populate?: string | string[];
   populateOptions?: PopulateOption[];
   lean?: boolean | 'true' | 'false';
+  /** Database-agnostic joins. Maps alias → collection or full lookup config. */
+  lookup?: Record<string, string | {
+    from: string;
+    localField: string;
+    foreignField: string;
+    select?: string;
+  }>;
   [key: string]: unknown;
 }
 interface RequestOptions {
@@ -212,12 +232,109 @@ declare class BaseApi<TDoc = Record<string, unknown>, TCreate = Partial<TDoc>, T
     params,
     options
   }?: {
-    token?: string;
+    token?: string | null;
     organizationId?: string | null;
     data?: unknown;
     params?: QueryParams;
     options?: Omit<RequestOptions, 'token' | 'organizationId'>;
   }): Promise<TResponse>;
+  getDeleted({
+    token,
+    organizationId,
+    params,
+    options
+  }?: {
+    token?: string | null;
+    organizationId?: string | null;
+    params?: QueryParams;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<PaginatedResponse<TDoc>>;
+  restore({
+    token,
+    organizationId,
+    id,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    id: string;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<ApiResponse<TDoc>>;
+  bulkCreate({
+    token,
+    organizationId,
+    data,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    data: TCreate[];
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<BulkCreateResponse<TDoc>>;
+  bulkUpdate({
+    token,
+    organizationId,
+    filter,
+    data,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    filter: Record<string, unknown>;
+    data: TUpdate;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<BulkUpdateResponse>;
+  bulkDelete({
+    token,
+    organizationId,
+    filter,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    filter: Record<string, unknown>;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<BulkDeleteResponse>;
+  getBySlug({
+    token,
+    organizationId,
+    slug,
+    params,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    slug: string;
+    params?: {
+      select?: string;
+      populate?: string | string[];
+    };
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<ApiResponse<TDoc>>;
+  getTree({
+    token,
+    organizationId,
+    params,
+    options
+  }?: {
+    token?: string | null;
+    organizationId?: string | null;
+    params?: QueryParams;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<ApiResponse<TDoc[]>>;
+  getChildren({
+    token,
+    organizationId,
+    parentId,
+    params,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    parentId: string;
+    params?: QueryParams;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<PaginatedResponse<TDoc>>;
 }
 declare function createCrudApi<TDoc = Record<string, unknown>, TCreate = Partial<TDoc>, TUpdate = Partial<TDoc>>(entity: string, config?: BaseApiConfig): BaseApi<TDoc, TCreate, TUpdate>;
 type ExtractDoc<T> = T extends PaginatedResponse<infer D> ? D : never;
@@ -225,4 +342,4 @@ declare function isOffsetPagination<T>(response: PaginatedResponse<T>): response
 declare function isKeysetPagination<T>(response: PaginatedResponse<T>): response is KeysetPaginationResponse<T>;
 declare function isAggregatePagination<T>(response: PaginatedResponse<T>): response is AggregatePaginationResponse<T>;
 //#endregion
-export { AggregatePaginationResponse, ApiResponse, BaseApi, BaseApiConfig, DeleteResponse, ExtractDoc, FilterOperator, KeysetPaginationResponse, OffsetPaginationResponse, PaginatedResponse, PopulateOption, QueryParams, RequestOptions, SortDirection, SortSpec, createCrudApi, isAggregatePagination, isKeysetPagination, isOffsetPagination };
+export { AggregatePaginationResponse, ApiResponse, BaseApi, BaseApiConfig, BulkCreateResponse, BulkDeleteResponse, BulkUpdateResponse, DeleteResponse, ExtractDoc, FilterOperator, KeysetPaginationResponse, OffsetPaginationResponse, PaginatedResponse, PopulateOption, QueryParams, RequestOptions, SortDirection, SortSpec, createCrudApi, isAggregatePagination, isKeysetPagination, isOffsetPagination };

package/dist/api.js

@@ -48,6 +48,19 @@ var BaseApi = class {
 				if (Array.isArray(value) && value.length > 0) result[key] = value;
 				return;
 			}
+			if (key === "lookup") {
+				if (typeof value === "object" && value !== null) Object.entries(value).forEach(([alias, lv]) => {
+					if (typeof lv === "string") result[`lookup[${alias}]`] = lv;
+					else if (typeof lv === "object" && lv !== null) {
+						const cfg = lv;
+						result[`lookup[${alias}][from]`] = cfg.from;
+						result[`lookup[${alias}][localField]`] = cfg.localField;
+						result[`lookup[${alias}][foreignField]`] = cfg.foreignField;
+						if (cfg.select) result[`lookup[${alias}][select]`] = cfg.select;
+					}
+				});
+				return;
+			}
 			if (value !== void 0 && value !== "") if (["page", "limit"].includes(key)) result[key] = parseInt(String(value)) || (key === "page" ? 1 : 10);
 			else if (Array.isArray(value)) {
 				if (value.length > 1) result[`${key}[in]`] = value.join(",");
@@ -83,7 +96,7 @@ var BaseApi = class {
 		if (organizationId) requestOptions.organizationId = organizationId;
 		return this.requestFn("GET", url, this.withHeaders(requestOptions));
 	}
-	async create({ token, organizationId = null, data, options = {} }) {
+	async create({ token = null, organizationId = null, data, options = {} }) {
 		const requestOptions = {
 			body: data,
 			...options
@@ -92,7 +105,7 @@ var BaseApi = class {
 		if (organizationId) requestOptions.organizationId = organizationId;
 		return this.requestFn("POST", this.baseUrl, this.withHeaders(requestOptions));
 	}
-	async update({ token, organizationId = null, id, data, options = {} }) {
+	async update({ token = null, organizationId = null, id, data, options = {} }) {
 		if (!id) throw new Error("ID is required");
 		const requestOptions = {
 			body: data,
@@ -102,14 +115,14 @@ var BaseApi = class {
 		if (organizationId) requestOptions.organizationId = organizationId;
 		return this.requestFn("PATCH", `${this.baseUrl}/${id}`, this.withHeaders(requestOptions));
 	}
-	async delete({ token, organizationId = null, id, options = {} }) {
+	async delete({ token = null, organizationId = null, id, options = {} }) {
 		if (!id) throw new Error("ID is required");
 		const requestOptions = { ...options };
 		if (token) requestOptions.token = token;
 		if (organizationId) requestOptions.organizationId = organizationId;
 		return this.requestFn("DELETE", `${this.baseUrl}/${id}`, this.withHeaders(requestOptions));
 	}
-	async upload({ token, organizationId = null, data, id, path, options = {} }) {
+	async upload({ token = null, organizationId = null, data, id, path, options = {} }) {
 		const suffix = path ?? (id ? `${id}/upload` : void 0);
 		const url = suffix ? `${this.baseUrl}/${suffix}` : this.baseUrl;
 		const requestOptions = {
@@ -154,7 +167,7 @@ var BaseApi = class {
 		if (organizationId) requestOptions.organizationId = organizationId;
 		return this.requestFn("GET", `${this.baseUrl}?${queryString}`, this.withHeaders(requestOptions));
 	}
-	async request(method, endpoint, { token, organizationId = null, data, params, options = {} } = {}) {
+	async request(method, endpoint, { token = null, organizationId = null, data, params, options = {} } = {}) {
 		let url = endpoint;
 		if (params) {
 			const processedParams = this.prepareParams(params);
@@ -169,6 +182,97 @@ var BaseApi = class {
 		if (organizationId) requestOptions.organizationId = organizationId;
 		return this.requestFn(method, url, this.withHeaders(requestOptions));
 	}
+	async getDeleted({ token = null, organizationId = null, params = {}, options = {} } = {}) {
+		const mergedParams = {
+			...this.config.defaultParams,
+			...params
+		};
+		const processedParams = this.prepareParams(mergedParams);
+		const queryString = this.createQueryString(processedParams);
+		const requestOptions = {
+			cache: this.config.cache,
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("GET", `${this.baseUrl}/deleted?${queryString}`, this.withHeaders(requestOptions));
+	}
+	async restore({ token = null, organizationId = null, id, options = {} }) {
+		if (!id) throw new Error("ID is required");
+		const requestOptions = { ...options };
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("POST", `${this.baseUrl}/${id}/restore`, this.withHeaders(requestOptions));
+	}
+	async bulkCreate({ token = null, organizationId = null, data, options = {} }) {
+		const requestOptions = {
+			body: data,
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("POST", `${this.baseUrl}/bulk`, this.withHeaders(requestOptions));
+	}
+	async bulkUpdate({ token = null, organizationId = null, filter, data, options = {} }) {
+		const requestOptions = {
+			body: {
+				filter,
+				data
+			},
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("PATCH", `${this.baseUrl}/bulk`, this.withHeaders(requestOptions));
+	}
+	async bulkDelete({ token = null, organizationId = null, filter, options = {} }) {
+		const requestOptions = {
+			body: { filter },
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("DELETE", `${this.baseUrl}/bulk`, this.withHeaders(requestOptions));
+	}
+	async getBySlug({ token = null, organizationId = null, slug, params = {}, options = {} }) {
+		if (!slug) throw new Error("Slug is required");
+		const queryString = this.createQueryString(params);
+		const url = queryString ? `${this.baseUrl}/slug/${slug}?${queryString}` : `${this.baseUrl}/slug/${slug}`;
+		const requestOptions = {
+			cache: this.config.cache,
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("GET", url, this.withHeaders(requestOptions));
+	}
+	async getTree({ token = null, organizationId = null, params = {}, options = {} } = {}) {
+		const processedParams = this.prepareParams(params);
+		const queryString = this.createQueryString(processedParams);
+		const requestOptions = {
+			cache: this.config.cache,
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("GET", `${this.baseUrl}/tree?${queryString}`, this.withHeaders(requestOptions));
+	}
+	async getChildren({ token = null, organizationId = null, parentId, params = {}, options = {} }) {
+		if (!parentId) throw new Error("Parent ID is required");
+		const mergedParams = {
+			...this.config.defaultParams,
+			...params
+		};
+		const processedParams = this.prepareParams(mergedParams);
+		const queryString = this.createQueryString(processedParams);
+		const requestOptions = {
+			cache: this.config.cache,
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("GET", `${this.baseUrl}/${parentId}/children?${queryString}`, this.withHeaders(requestOptions));
+	}
 };
 function createCrudApi(entity, config = {}) {
 	return new BaseApi(entity, config);