@elqnt/entity 2.1.2 → 2.2.0

package/README.md

@@ -106,30 +106,45 @@ React Component
 
 | Hook | Description |
 |------|-------------|
-| `useEntities(options)` | Full CRUD operations with loading/error states |
+| `useEntityDefinitions(options)` | Entity definition CRUD operations |
+| `useEntityRecords(options)` | Entity record CRUD with bulk operations and count |
+| `useEntities(options)` | Legacy combined hook (backward compatible) |
 
-Use `useEntities` inside your app-specific hooks (not directly in components):
+**Recommended: Use specialized hooks for better separation of concerns:**
+
+```tsx
+import { useEntityDefinitions, useEntityRecords } from "@elqnt/entity/hooks";
+
+// For entity schema management
+const { listDefinitions, getDefinition, createDefinition, updateDefinition, deleteDefinition, loading, error } = useEntityDefinitions({
+  baseUrl: config.apiGatewayUrl,
+  orgId: config.orgId,
+});
+
+// For entity record operations (scoped to a specific entity)
+const { queryRecords, getRecord, createRecord, updateRecord, deleteRecord, countRecords, bulkCreate, bulkUpdate, bulkDelete, loading, error } = useEntityRecords({
+  baseUrl: config.apiGatewayUrl,
+  orgId: config.orgId,
+  entityName: "contacts",
+});
+```
+
+**Legacy hook (still supported):**
 
 ```tsx
-// Inside your custom hook
 import { useEntities } from "@elqnt/entity/hooks";
 
-export function useMyEntities() {
-  const {
-    queryRecords,   // Query multiple records with filters/pagination
-    getRecord,      // Get single record by ID
-    createRecord,   // Create new record
-    updateRecord,   // Update existing record
-    deleteRecord,   // Delete record
-    listDefinitions,// List entity definitions
-    getDefinition,  // Get entity definition by name
-    loading,        // Loading state
-    error,          // Error message
-  } = useEntities({ baseUrl, orgId });
-
-  // Transform and expose domain-specific functions
-  // ...
-}
+const {
+  queryRecords,   // Query multiple records with filters/pagination
+  getRecord,      // Get single record by ID
+  createRecord,   // Create new record
+  updateRecord,   // Update existing record
+  deleteRecord,   // Delete record
+  listDefinitions,// List entity definitions
+  getDefinition,  // Get entity definition by name
+  loading,        // Loading state
+  error,          // Error message
+} = useEntities({ baseUrl, orgId });
 ```
 
 ### `/api` - API Functions
@@ -159,9 +174,45 @@ import {
 
   // Count
   countEntityRecordsApi,
+
+  // Provisioning
+  provisionEntitiesApi,
 } from "@elqnt/entity/api";
 ```
 
+### Provisioning Entities (Admin)
+
+Use `provisionEntitiesApi` to set up default entity definitions for an organization:
+
+```typescript
+import { provisionEntitiesApi } from "@elqnt/entity/api";
+import type { EntityDefinition } from "@elqnt/entity/models";
+
+const definitions: EntityDefinition[] = [{
+  name: "ticket",
+  displayName: "Support Ticket",
+  description: "Customer support tickets",
+  schema: {
+    type: "object",
+    properties: {
+      title: { type: "string" },
+      status: { type: "string", enum: ["open", "closed"] },
+    },
+    required: ["title", "status"],
+  },
+  isActive: true,
+}];
+
+const result = await provisionEntitiesApi(definitions, {
+  baseUrl: "https://api.elqnt.ai",
+  orgId: "org-uuid",
+});
+
+if (result.data?.success) {
+  console.log(`Created: ${result.data.created}, Updated: ${result.data.updated}`);
+}
+```
+
 ### `/models` - TypeScript Types
 
 Types generated from Go via tygo.

package/dist/api/index.d.mts

@@ -1,6 +1,6 @@
 import { ApiClientOptions, ApiResponse } from '@elqnt/api-client';
 import { ResponseMetadata } from '@elqnt/types';
-import { ListEntityDefinitionsResponse, EntityDefinitionResponse, EntityDefinition, ListEntityRecordsResponse, EntityRecordResponse, EntityRecord } from '../models/index.mjs';
+import { EntityRecord, EntityDefinition, EntityDefinitionResponse, EntityRecordResponse, ListEntityDefinitionsResponse, ListEntityRecordsResponse } from '../models/index.mjs';
 
 /**
  * Entity API functions
@@ -41,5 +41,20 @@ declare function countEntityRecordsApi(entityName: string, filters: Record<strin
     count: number;
     metadata: ResponseMetadata;
 }>>;
+interface ProvisionEntitiesResponse {
+    created: number;
+    updated: number;
+    errors: string[];
+    success: boolean;
+    metadata: ResponseMetadata;
+}
+/**
+ * Provision entity definitions for an organization.
+ * Creates or updates entity definitions in bulk.
+ *
+ * @param definitions - Array of EntityDefinition to provision
+ * @param options - API client options (baseUrl, orgId)
+ */
+declare function provisionEntitiesApi(definitions: EntityDefinition[], options: ApiClientOptions): Promise<ApiResponse<ProvisionEntitiesResponse>>;
 
-export { bulkCreateEntityRecordsApi, bulkDeleteEntityRecordsApi, bulkUpdateEntityRecordsApi, countEntityRecordsApi, createEntityDefinitionApi, createEntityRecordApi, deleteEntityDefinitionApi, deleteEntityRecordApi, getEntityDefinitionApi, getEntityRecordApi, listEntityDefinitionsApi, queryEntityRecordsApi, updateEntityDefinitionApi, updateEntityRecordApi };
+export { type ProvisionEntitiesResponse, bulkCreateEntityRecordsApi, bulkDeleteEntityRecordsApi, bulkUpdateEntityRecordsApi, countEntityRecordsApi, createEntityDefinitionApi, createEntityRecordApi, deleteEntityDefinitionApi, deleteEntityRecordApi, getEntityDefinitionApi, getEntityRecordApi, listEntityDefinitionsApi, provisionEntitiesApi, queryEntityRecordsApi, updateEntityDefinitionApi, updateEntityRecordApi };

package/dist/api/index.d.ts

@@ -1,6 +1,6 @@
 import { ApiClientOptions, ApiResponse } from '@elqnt/api-client';
 import { ResponseMetadata } from '@elqnt/types';
-import { ListEntityDefinitionsResponse, EntityDefinitionResponse, EntityDefinition, ListEntityRecordsResponse, EntityRecordResponse, EntityRecord } from '../models/index.js';
+import { EntityRecord, EntityDefinition, EntityDefinitionResponse, EntityRecordResponse, ListEntityDefinitionsResponse, ListEntityRecordsResponse } from '../models/index.js';
 
 /**
  * Entity API functions
@@ -41,5 +41,20 @@ declare function countEntityRecordsApi(entityName: string, filters: Record<strin
     count: number;
     metadata: ResponseMetadata;
 }>>;
+interface ProvisionEntitiesResponse {
+    created: number;
+    updated: number;
+    errors: string[];
+    success: boolean;
+    metadata: ResponseMetadata;
+}
+/**
+ * Provision entity definitions for an organization.
+ * Creates or updates entity definitions in bulk.
+ *
+ * @param definitions - Array of EntityDefinition to provision
+ * @param options - API client options (baseUrl, orgId)
+ */
+declare function provisionEntitiesApi(definitions: EntityDefinition[], options: ApiClientOptions): Promise<ApiResponse<ProvisionEntitiesResponse>>;
 
-export { bulkCreateEntityRecordsApi, bulkDeleteEntityRecordsApi, bulkUpdateEntityRecordsApi, countEntityRecordsApi, createEntityDefinitionApi, createEntityRecordApi, deleteEntityDefinitionApi, deleteEntityRecordApi, getEntityDefinitionApi, getEntityRecordApi, listEntityDefinitionsApi, queryEntityRecordsApi, updateEntityDefinitionApi, updateEntityRecordApi };
+export { type ProvisionEntitiesResponse, bulkCreateEntityRecordsApi, bulkDeleteEntityRecordsApi, bulkUpdateEntityRecordsApi, countEntityRecordsApi, createEntityDefinitionApi, createEntityRecordApi, deleteEntityDefinitionApi, deleteEntityRecordApi, getEntityDefinitionApi, getEntityRecordApi, listEntityDefinitionsApi, provisionEntitiesApi, queryEntityRecordsApi, updateEntityDefinitionApi, updateEntityRecordApi };

package/dist/api/index.js

@@ -14,8 +14,8 @@
 
 
 
-var _chunkSXBB42DJjs = require('../chunk-SXBB42DJ.js');
 
+var _chunk6SB5QDL5js = require('../chunk-6SB5QDL5.js');
 
 
 
@@ -30,5 +30,7 @@ var _chunkSXBB42DJjs = require('../chunk-SXBB42DJ.js');
 
 
 
-exports.bulkCreateEntityRecordsApi = _chunkSXBB42DJjs.bulkCreateEntityRecordsApi; exports.bulkDeleteEntityRecordsApi = _chunkSXBB42DJjs.bulkDeleteEntityRecordsApi; exports.bulkUpdateEntityRecordsApi = _chunkSXBB42DJjs.bulkUpdateEntityRecordsApi; exports.countEntityRecordsApi = _chunkSXBB42DJjs.countEntityRecordsApi; exports.createEntityDefinitionApi = _chunkSXBB42DJjs.createEntityDefinitionApi; exports.createEntityRecordApi = _chunkSXBB42DJjs.createEntityRecordApi; exports.deleteEntityDefinitionApi = _chunkSXBB42DJjs.deleteEntityDefinitionApi; exports.deleteEntityRecordApi = _chunkSXBB42DJjs.deleteEntityRecordApi; exports.getEntityDefinitionApi = _chunkSXBB42DJjs.getEntityDefinitionApi; exports.getEntityRecordApi = _chunkSXBB42DJjs.getEntityRecordApi; exports.listEntityDefinitionsApi = _chunkSXBB42DJjs.listEntityDefinitionsApi; exports.queryEntityRecordsApi = _chunkSXBB42DJjs.queryEntityRecordsApi; exports.updateEntityDefinitionApi = _chunkSXBB42DJjs.updateEntityDefinitionApi; exports.updateEntityRecordApi = _chunkSXBB42DJjs.updateEntityRecordApi;
+
+
+exports.bulkCreateEntityRecordsApi = _chunk6SB5QDL5js.bulkCreateEntityRecordsApi; exports.bulkDeleteEntityRecordsApi = _chunk6SB5QDL5js.bulkDeleteEntityRecordsApi; exports.bulkUpdateEntityRecordsApi = _chunk6SB5QDL5js.bulkUpdateEntityRecordsApi; exports.countEntityRecordsApi = _chunk6SB5QDL5js.countEntityRecordsApi; exports.createEntityDefinitionApi = _chunk6SB5QDL5js.createEntityDefinitionApi; exports.createEntityRecordApi = _chunk6SB5QDL5js.createEntityRecordApi; exports.deleteEntityDefinitionApi = _chunk6SB5QDL5js.deleteEntityDefinitionApi; exports.deleteEntityRecordApi = _chunk6SB5QDL5js.deleteEntityRecordApi; exports.getEntityDefinitionApi = _chunk6SB5QDL5js.getEntityDefinitionApi; exports.getEntityRecordApi = _chunk6SB5QDL5js.getEntityRecordApi; exports.listEntityDefinitionsApi = _chunk6SB5QDL5js.listEntityDefinitionsApi; exports.provisionEntitiesApi = _chunk6SB5QDL5js.provisionEntitiesApi; exports.queryEntityRecordsApi = _chunk6SB5QDL5js.queryEntityRecordsApi; exports.updateEntityDefinitionApi = _chunk6SB5QDL5js.updateEntityDefinitionApi; exports.updateEntityRecordApi = _chunk6SB5QDL5js.updateEntityRecordApi;
 //# sourceMappingURL=index.js.map

package/dist/api/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/eloquent-packages/eloquent-packages/packages/entity/dist/api/index.js"],"names":[],"mappings":"AAAA,qFAAY;AACZ;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,uDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,uiCAAC","file":"/home/runner/work/eloquent-packages/eloquent-packages/packages/entity/dist/api/index.js"}
+{"version":3,"sources":["/home/runner/work/eloquent/eloquent/packages/@elqnt/entity/dist/api/index.js"],"names":[],"mappings":"AAAA,qFAAY;AACZ;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,uDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,6mCAAC","file":"/home/runner/work/eloquent/eloquent/packages/@elqnt/entity/dist/api/index.js"}

package/dist/api/index.mjs

@@ -11,10 +11,11 @@ import {
   getEntityDefinitionApi,
   getEntityRecordApi,
   listEntityDefinitionsApi,
+  provisionEntitiesApi,
   queryEntityRecordsApi,
   updateEntityDefinitionApi,
   updateEntityRecordApi
-} from "../chunk-UHASYUCH.mjs";
+} from "../chunk-SHMUKUYC.mjs";
 export {
   bulkCreateEntityRecordsApi,
   bulkDeleteEntityRecordsApi,
@@ -27,6 +28,7 @@ export {
   getEntityDefinitionApi,
   getEntityRecordApi,
   listEntityDefinitionsApi,
+  provisionEntitiesApi,
   queryEntityRecordsApi,
   updateEntityDefinitionApi,
   updateEntityRecordApi

package/dist/chunk-5BPHCJ2G.js

@@ -0,0 +1,427 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }"use client";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk6SB5QDL5js = require('./chunk-6SB5QDL5.js');
+
+// hooks/use-entity-definitions.ts
+var _react = require('react');
+
+// hooks/use-async.ts
+
+function useAsync(asyncFn, transform, defaultValue, options = {}) {
+  const { resetErrorOnRequest = true } = options;
+  const [loading, setLoading] = _react.useState.call(void 0, false);
+  const [error, setError] = _react.useState.call(void 0, null);
+  const execute = _react.useCallback.call(void 0, 
+    async (...args) => {
+      setLoading(true);
+      if (resetErrorOnRequest) {
+        setError(null);
+      }
+      try {
+        const response = await asyncFn(...args);
+        if (response.error) {
+          setError(response.error);
+          return defaultValue;
+        }
+        if (!response.data) {
+          return defaultValue;
+        }
+        return transform(response.data);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "An error occurred";
+        setError(message);
+        return defaultValue;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [asyncFn, transform, defaultValue, resetErrorOnRequest]
+  );
+  return { execute, loading, error };
+}
+function useApiAsync(asyncFn, transform, defaultValue) {
+  return useAsync(asyncFn, transform, defaultValue);
+}
+
+// hooks/use-options-ref.ts
+
+function useOptionsRef(options) {
+  const optionsRef = _react.useRef.call(void 0, options);
+  _react.useEffect.call(void 0, () => {
+    optionsRef.current = options;
+  }, [options]);
+  return optionsRef;
+}
+
+// hooks/use-entity-definitions.ts
+function useEntityDefinitions(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: listDefinitions, loading: listLoading, error: listError } = useApiAsync(
+    () => _chunk6SB5QDL5js.listEntityDefinitionsApi.call(void 0, optionsRef.current),
+    (data) => data.definitions || [],
+    []
+  );
+  const { execute: getDefinition, loading: getLoading, error: getError } = useApiAsync(
+    (entityName) => _chunk6SB5QDL5js.getEntityDefinitionApi.call(void 0, entityName, optionsRef.current),
+    (data) => data.definition || null,
+    null
+  );
+  const { execute: createDefinition, loading: createLoading, error: createError } = useApiAsync(
+    (definition) => _chunk6SB5QDL5js.createEntityDefinitionApi.call(void 0, definition, optionsRef.current),
+    (data) => data.definition || null,
+    null
+  );
+  const { execute: updateDefinition, loading: updateLoading, error: updateError } = useApiAsync(
+    (entityName, definition) => _chunk6SB5QDL5js.updateEntityDefinitionApi.call(void 0, entityName, definition, optionsRef.current),
+    (data) => data.definition || null,
+    null
+  );
+  const { execute: deleteDefinition, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (entityName) => _chunk6SB5QDL5js.deleteEntityDefinitionApi.call(void 0, entityName, optionsRef.current),
+    (data) => data.success,
+    false
+  );
+  const loading = listLoading || getLoading || createLoading || updateLoading || deleteLoading;
+  const error = listError || getError || createError || updateError || deleteError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listDefinitions,
+      getDefinition,
+      createDefinition,
+      updateDefinition,
+      deleteDefinition
+    }),
+    [loading, error, listDefinitions, getDefinition, createDefinition, updateDefinition, deleteDefinition]
+  );
+}
+
+// hooks/use-entity-records.ts
+
+function useEntityRecords(options) {
+  const optionsRef = useOptionsRef(options);
+  const getEntityName = () => optionsRef.current.entityName;
+  const getApiOptions = () => {
+    const { entityName: _, ...apiOptions } = optionsRef.current;
+    return apiOptions;
+  };
+  const { execute: queryRecords, loading: queryLoading, error: queryError } = useApiAsync(
+    (params) => {
+      const queryParams = {
+        page: _optionalChain([params, 'optionalAccess', _2 => _2.page]) || 1,
+        pageSize: _optionalChain([params, 'optionalAccess', _3 => _3.pageSize]) || 20
+      };
+      if (_optionalChain([params, 'optionalAccess', _4 => _4.filters])) {
+        queryParams.filters = JSON.stringify(params.filters);
+      }
+      if (_optionalChain([params, 'optionalAccess', _5 => _5.sortBy])) {
+        queryParams.sortBy = params.sortBy;
+      }
+      if (_optionalChain([params, 'optionalAccess', _6 => _6.sortOrder])) {
+        queryParams.sortOrder = params.sortOrder;
+      }
+      return _chunk6SB5QDL5js.queryEntityRecordsApi.call(void 0, getEntityName(), queryParams, getApiOptions());
+    },
+    (data) => {
+      if (_optionalChain([data, 'optionalAccess', _7 => _7.records, 'optionalAccess', _8 => _8.items])) {
+        return {
+          records: data.records.items,
+          total: data.records.totalCount,
+          page: data.records.currentPage,
+          pageSize: data.records.pageSize
+        };
+      }
+      return {
+        records: _optionalChain([data, 'optionalAccess', _9 => _9.records]) || [],
+        total: _optionalChain([data, 'optionalAccess', _10 => _10.total]) || 0,
+        page: _optionalChain([data, 'optionalAccess', _11 => _11.page]) || 1,
+        pageSize: _optionalChain([data, 'optionalAccess', _12 => _12.pageSize]) || 20
+      };
+    },
+    { records: [], total: 0, page: 1, pageSize: 20 }
+  );
+  const { execute: getRecord, loading: getLoading, error: getError } = useApiAsync(
+    (recordId) => _chunk6SB5QDL5js.getEntityRecordApi.call(void 0, getEntityName(), recordId, getApiOptions()),
+    (data) => data.record || null,
+    null
+  );
+  const { execute: createRecord, loading: createLoading, error: createError } = useApiAsync(
+    (record) => _chunk6SB5QDL5js.createEntityRecordApi.call(void 0, getEntityName(), record, getApiOptions()),
+    (data) => data.record || null,
+    null
+  );
+  const { execute: updateRecord, loading: updateLoading, error: updateError } = useApiAsync(
+    (recordId, record) => _chunk6SB5QDL5js.updateEntityRecordApi.call(void 0, getEntityName(), recordId, record, getApiOptions()),
+    (data) => data.record || null,
+    null
+  );
+  const { execute: deleteRecord, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (recordId) => _chunk6SB5QDL5js.deleteEntityRecordApi.call(void 0, getEntityName(), recordId, getApiOptions()),
+    (data) => data.success,
+    false
+  );
+  const { execute: countRecords, loading: countLoading, error: countError } = useApiAsync(
+    (filters) => _chunk6SB5QDL5js.countEntityRecordsApi.call(void 0, getEntityName(), filters || {}, getApiOptions()),
+    (data) => data.count,
+    0
+  );
+  const { execute: bulkCreate, loading: bulkCreateLoading, error: bulkCreateError } = useApiAsync(
+    (records) => _chunk6SB5QDL5js.bulkCreateEntityRecordsApi.call(void 0, getEntityName(), records, getApiOptions()),
+    (data) => ({ records: data.records, success: true }),
+    { success: false }
+  );
+  const { execute: bulkUpdate, loading: bulkUpdateLoading, error: bulkUpdateError } = useApiAsync(
+    (records) => _chunk6SB5QDL5js.bulkUpdateEntityRecordsApi.call(void 0, getEntityName(), records, getApiOptions()),
+    (data) => ({ records: data.records, success: true }),
+    { success: false }
+  );
+  const { execute: bulkDelete, loading: bulkDeleteLoading, error: bulkDeleteError } = useApiAsync(
+    (recordIds) => _chunk6SB5QDL5js.bulkDeleteEntityRecordsApi.call(void 0, getEntityName(), recordIds, getApiOptions()),
+    (data) => data.success,
+    false
+  );
+  const loading = queryLoading || getLoading || createLoading || updateLoading || deleteLoading || countLoading || bulkCreateLoading || bulkUpdateLoading || bulkDeleteLoading;
+  const error = queryError || getError || createError || updateError || deleteError || countError || bulkCreateError || bulkUpdateError || bulkDeleteError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      queryRecords,
+      getRecord,
+      createRecord,
+      updateRecord,
+      deleteRecord,
+      countRecords,
+      bulkCreate,
+      bulkUpdate,
+      bulkDelete
+    }),
+    [
+      loading,
+      error,
+      queryRecords,
+      getRecord,
+      createRecord,
+      updateRecord,
+      deleteRecord,
+      countRecords,
+      bulkCreate,
+      bulkUpdate,
+      bulkDelete
+    ]
+  );
+}
+
+// hooks/use-entities.ts
+
+function useEntities(options) {
+  const [loading, setLoading] = _react.useState.call(void 0, false);
+  const [error, setError] = _react.useState.call(void 0, null);
+  const listDefinitions = _react.useCallback.call(void 0, async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await _chunk6SB5QDL5js.listEntityDefinitionsApi.call(void 0, options);
+      if (response.error) {
+        setError(response.error);
+        return [];
+      }
+      return _optionalChain([response, 'access', _13 => _13.data, 'optionalAccess', _14 => _14.definitions]) || [];
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to load definitions";
+      setError(message);
+      return [];
+    } finally {
+      setLoading(false);
+    }
+  }, [options]);
+  const getDefinition = _react.useCallback.call(void 0, 
+    async (entityName) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await _chunk6SB5QDL5js.getEntityDefinitionApi.call(void 0, entityName, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return _optionalChain([response, 'access', _15 => _15.data, 'optionalAccess', _16 => _16.definition]) || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get definition";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const queryRecords = _react.useCallback.call(void 0, 
+    async (entityName, query = {}) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const queryParams = {
+          page: query.page || 1,
+          pageSize: query.pageSize || 20
+        };
+        if (query.filters) {
+          queryParams.filters = JSON.stringify(query.filters);
+        }
+        if (query.sortBy) {
+          queryParams.sortBy = query.sortBy;
+        }
+        if (query.sortOrder) {
+          queryParams.sortOrder = query.sortOrder;
+        }
+        const response = await _chunk6SB5QDL5js.queryEntityRecordsApi.call(void 0, entityName, queryParams, options);
+        if (response.error) {
+          setError(response.error);
+          return { records: [], total: 0, page: 1, pageSize: 20 };
+        }
+        const data = response.data;
+        if (_optionalChain([data, 'optionalAccess', _17 => _17.records, 'optionalAccess', _18 => _18.items])) {
+          return {
+            records: data.records.items,
+            total: data.records.totalCount,
+            page: data.records.currentPage,
+            pageSize: data.records.pageSize
+          };
+        }
+        return {
+          records: _optionalChain([data, 'optionalAccess', _19 => _19.records]) || [],
+          total: _optionalChain([data, 'optionalAccess', _20 => _20.total]) || 0,
+          page: _optionalChain([data, 'optionalAccess', _21 => _21.page]) || 1,
+          pageSize: _optionalChain([data, 'optionalAccess', _22 => _22.pageSize]) || 20
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to query records";
+        setError(message);
+        return { records: [], total: 0, page: 1, pageSize: 20 };
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const getRecord = _react.useCallback.call(void 0, 
+    async (entityName, recordId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await _chunk6SB5QDL5js.getEntityRecordApi.call(void 0, entityName, recordId, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return _optionalChain([response, 'access', _23 => _23.data, 'optionalAccess', _24 => _24.record]) || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get record";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const createRecord = _react.useCallback.call(void 0, 
+    async (entityName, record) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await _chunk6SB5QDL5js.createEntityRecordApi.call(void 0, entityName, record, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return _optionalChain([response, 'access', _25 => _25.data, 'optionalAccess', _26 => _26.record]) || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to create record";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const updateRecord = _react.useCallback.call(void 0, 
+    async (entityName, recordId, record) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await _chunk6SB5QDL5js.updateEntityRecordApi.call(void 0, entityName, recordId, record, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return _optionalChain([response, 'access', _27 => _27.data, 'optionalAccess', _28 => _28.record]) || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to update record";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const deleteRecord = _react.useCallback.call(void 0, 
+    async (entityName, recordId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await _chunk6SB5QDL5js.deleteEntityRecordApi.call(void 0, entityName, recordId, options);
+        if (response.error) {
+          setError(response.error);
+          return false;
+        }
+        return true;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to delete record";
+        setError(message);
+        return false;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  return {
+    loading,
+    error,
+    listDefinitions,
+    getDefinition,
+    queryRecords,
+    getRecord,
+    createRecord,
+    updateRecord,
+    deleteRecord
+  };
+}
+
+
+
+
+
+
+
+
+exports.useAsync = useAsync; exports.useApiAsync = useApiAsync; exports.useOptionsRef = useOptionsRef; exports.useEntityDefinitions = useEntityDefinitions; exports.useEntityRecords = useEntityRecords; exports.useEntities = useEntities;
+//# sourceMappingURL=chunk-5BPHCJ2G.js.map