@elqnt/entity 1.0.7 → 2.0.0

package/dist/index.mjs

@@ -73,14 +73,6 @@ import {
   RecordChangeActionUpdated
 } from "./chunk-LIACJMHV.mjs";
 
-// context/entity-definition-context.tsx
-import { createContext, useContext, useMemo } from "react";
-
-// hooks/use-entity-definition.ts
-import { useCallback, useEffect } from "react";
-import { useDispatch, useSelector } from "react-redux";
-import { useNatsContext } from "@elqnt/nats";
-
 // store/entity-definition-slice.ts
 import { createSlice } from "@reduxjs/toolkit";
 var initialState = {
@@ -187,364 +179,6 @@ var {
 } = entityDefinitionSlice.actions;
 var entityDefinitionReducer = entityDefinitionSlice.reducer;
 
-// hooks/use-entity-definition.ts
-function useEntityDefinition(orgId, entityName, options = {}) {
-  const { autoLoad, module } = options;
-  const { natsConnected, request } = useNatsContext();
-  const dispatch = useDispatch();
-  const definitions = useSelector(
-    (state) => state.entityDefinition.definitions
-  );
-  const selectedDefinition = useSelector(
-    (state) => state.entityDefinition.selectedDefinition
-  );
-  const views = useSelector(
-    (state) => state.entityDefinition.views
-  );
-  const selectedView = useSelector(
-    (state) => state.entityDefinition.selectedView
-  );
-  const isLoading = useSelector(
-    (state) => state.entityDefinition.isLoading
-  );
-  const loadingStates = useSelector(
-    (state) => state.entityDefinition.loadingStates
-  );
-  const error = useSelector(
-    (state) => state.entityDefinition.error
-  );
-  const createOrgSchema = useCallback(
-    async (targetOrgId) => {
-      if (!natsConnected) {
-        throw new Error("Not connected to NATS");
-      }
-      dispatch(setOperationLoading({ operation: "createOrgSchema", loading: true }));
-      try {
-        const response = await request(EntityOrgSchemaCreate, { orgId: targetOrgId });
-        if (response instanceof Error) {
-          throw response;
-        }
-        return response;
-      } finally {
-        dispatch(setOperationLoading({ operation: "createOrgSchema", loading: false }));
-      }
-    },
-    [natsConnected, dispatch, request]
-  );
-  const dropOrgSchema = useCallback(
-    async (targetOrgId) => {
-      if (!natsConnected) {
-        throw new Error("Not connected to NATS");
-      }
-      dispatch(setOperationLoading({ operation: "dropOrgSchema", loading: true }));
-      try {
-        const response = await request(EntityOrgSchemaDrop, { orgId: targetOrgId });
-        if (response instanceof Error) {
-          throw response;
-        }
-        return response;
-      } finally {
-        dispatch(setOperationLoading({ operation: "dropOrgSchema", loading: false }));
-      }
-    },
-    [natsConnected, dispatch, request]
-  );
-  const loadDefinitions = useCallback(async () => {
-    if (!natsConnected || !orgId) return;
-    const loadingKey = "loadDefinitions";
-    if (loadingStates[loadingKey]) return;
-    dispatch(setOperationLoading({ operation: loadingKey, loading: true }));
-    try {
-      const response = await request(EntityDefinitionList, { orgId, module });
-      if (response instanceof Error) {
-        dispatch(setError(response.message));
-      } else {
-        dispatch(setDefinitions(response?.definitions ?? []));
-      }
-    } catch (err) {
-      dispatch(setError(err instanceof Error ? err.message : "Unknown error"));
-    } finally {
-      dispatch(setOperationLoading({ operation: loadingKey, loading: false }));
-    }
-  }, [natsConnected, orgId, options.module, dispatch, request]);
-  useEffect(() => {
-    let mounted = true;
-    if (autoLoad && natsConnected && orgId && mounted) {
-      loadDefinitions();
-    }
-    return () => {
-      mounted = false;
-    };
-  }, [autoLoad, natsConnected, orgId]);
-  const loadDefinition = useCallback(
-    async (name) => {
-      if (!natsConnected || !orgId) return;
-      dispatch(
-        setOperationLoading({ operation: `load_${name}`, loading: true })
-      );
-      try {
-        const response = await request(EntityDefinitionGet, { entityName: name, orgId }, {});
-        if (response instanceof Error) {
-          dispatch(setError(response.message));
-          return;
-        }
-        dispatch(setSelectedDefinition(response.definition));
-      } finally {
-        dispatch(
-          setOperationLoading({ operation: `load_${name}`, loading: false })
-        );
-      }
-    },
-    [natsConnected, orgId, dispatch, request]
-  );
-  useEffect(() => {
-    if (natsConnected && orgId && entityName) {
-      loadDefinition(entityName);
-    }
-  }, [natsConnected, orgId, entityName, loadDefinition]);
-  const createDefinition = async (definition) => {
-    if (!natsConnected || !orgId) {
-      throw new Error("Not connected or missing orgId");
-    }
-    dispatch(setOperationLoading({ operation: "create", loading: true }));
-    try {
-      const response = await request(EntityDefinitionCreate, { definition, orgId }, {});
-      if (response instanceof Error) {
-        console.error("createDefinition error", response);
-        throw response;
-      }
-      if (response.metadata.success) {
-        dispatch(addDefinition(response.definition));
-      }
-      return response;
-    } finally {
-      dispatch(setOperationLoading({ operation: "create", loading: false }));
-    }
-  };
-  const updateDefinitionById = async (name, definition) => {
-    if (!natsConnected || !orgId) {
-      throw new Error("Not connected or missing orgId");
-    }
-    dispatch(
-      setOperationLoading({ operation: `update_${name}`, loading: true })
-    );
-    try {
-      const response = await request(
-        EntityDefinitionUpdate,
-        {
-          entityName: name,
-          definition,
-          orgId
-        },
-        {}
-      );
-      if (response instanceof Error) {
-        throw response;
-      }
-      if (response.metadata.success) {
-        dispatch(updateDefinition(response.definition));
-      }
-      return response;
-    } finally {
-      dispatch(
-        setOperationLoading({ operation: `update_${name}`, loading: false })
-      );
-    }
-  };
-  const deleteDefinition = async (name) => {
-    if (!natsConnected || !orgId) {
-      throw new Error("Not connected or missing orgId");
-    }
-    dispatch(
-      setOperationLoading({ operation: `delete_${name}`, loading: true })
-    );
-    try {
-      const response = await request(EntityDefinitionDelete, { entityName: name, orgId }, {});
-      if (response instanceof Error) {
-        throw response;
-      }
-      dispatch(removeDefinition(name));
-      return response;
-    } finally {
-      dispatch(
-        setOperationLoading({ operation: `delete_${name}`, loading: false })
-      );
-    }
-  };
-  const loadViews = useCallback(
-    async (entityName2) => {
-      if (!natsConnected || !orgId) return;
-      const loadingKey = `loadViews_${entityName2}`;
-      if (loadingStates[loadingKey]) return;
-      dispatch(setOperationLoading({ operation: loadingKey, loading: true }));
-      try {
-        const response = await request(
-          EntityViewList,
-          { entityName: entityName2, orgId },
-          {}
-        );
-        console.log("loadViews response", response);
-        if (response instanceof Error) {
-          dispatch(setError(response.message));
-          return;
-        }
-        dispatch(setViews({ entityName: entityName2, views: response.views }));
-      } catch (err) {
-        dispatch(
-          setError(err instanceof Error ? err.message : "Unknown error")
-        );
-      } finally {
-        dispatch(
-          setOperationLoading({ operation: loadingKey, loading: false })
-        );
-      }
-    },
-    [natsConnected, orgId, loadingStates, dispatch, request]
-  );
-  const createView = async (entityName2, view) => {
-    if (!natsConnected || !orgId) {
-      throw new Error("Not connected or missing orgId");
-    }
-    dispatch(setOperationLoading({ operation: "create_view", loading: true }));
-    try {
-      const response = await request(
-        EntityViewCreate,
-        { entityName: entityName2, view, orgId },
-        {}
-      );
-      if (response instanceof Error) {
-        throw response;
-      }
-      dispatch(addView({ entityName: entityName2, view: response.view }));
-      return response.view;
-    } finally {
-      dispatch(
-        setOperationLoading({ operation: "create_view", loading: false })
-      );
-    }
-  };
-  const updateViewById = async (entityName2, view) => {
-    if (!natsConnected || !orgId || !view.id) {
-      throw new Error("Not connected, missing orgId, or invalid view");
-    }
-    dispatch(
-      setOperationLoading({
-        operation: `update_view_${view.id}`,
-        loading: true
-      })
-    );
-    try {
-      const response = await request(
-        EntityViewUpdate,
-        { view, orgId },
-        {}
-      );
-      if (response instanceof Error) {
-        throw response;
-      }
-      dispatch(updateView({ entityName: entityName2, view: response.view }));
-      return response.view;
-    } finally {
-      dispatch(
-        setOperationLoading({
-          operation: `update_view_${view.id}`,
-          loading: false
-        })
-      );
-    }
-  };
-  const deleteView = async (entityName2, viewId) => {
-    if (!natsConnected || !orgId) {
-      throw new Error("Not connected or missing orgId");
-    }
-    dispatch(
-      setOperationLoading({ operation: `delete_view_${viewId}`, loading: true })
-    );
-    try {
-      const response = await request(
-        EntityViewDelete,
-        { viewId, orgId },
-        {}
-      );
-      if (response instanceof Error) {
-        throw response;
-      }
-      dispatch(removeView({ entityName: entityName2, viewId }));
-      return response;
-    } finally {
-      dispatch(
-        setOperationLoading({
-          operation: `delete_view_${viewId}`,
-          loading: false
-        })
-      );
-    }
-  };
-  const refresh = useCallback(() => {
-    if (!natsConnected || !orgId) return;
-    if (entityName) {
-      loadDefinition(entityName);
-    } else {
-      dispatch(setLoading(true));
-      loadDefinitions().finally(() => dispatch(setLoading(false)));
-    }
-  }, [natsConnected, orgId, entityName, loadDefinition, dispatch]);
-  return {
-    // State
-    definitions,
-    selectedDefinition,
-    views,
-    selectedView,
-    isLoading,
-    loadingStates,
-    error,
-    // Organization operations
-    createOrgSchema,
-    dropOrgSchema,
-    // Definition operations
-    loadDefinitions,
-    loadDefinition,
-    createDefinition,
-    updateDefinition: updateDefinitionById,
-    deleteDefinition,
-    // View operations
-    loadViews,
-    createView,
-    updateView: updateViewById,
-    deleteView,
-    // Utilities
-    refresh
-  };
-}
-
-// hooks/use-entity-definition-details.ts
-import { useCallback as useCallback2, useEffect as useEffect2 } from "react";
-function useEntityDefinitionDetails(entityName) {
-  const context = useEntityDefinitionContext();
-  const definition = context.definitions[entityName];
-  const loadDefinitionDetails = useCallback2(async () => {
-    return context.loadDefinition(entityName);
-  }, [context, entityName]);
-  useEffect2(() => {
-    if (entityName && !definition) {
-      loadDefinitionDetails();
-    }
-  }, [definition, entityName, loadDefinitionDetails]);
-  return {
-    definition,
-    isLoading: context.loadingStates[`load_${entityName}`],
-    error: context.error,
-    updateDefinition: (updatedDef) => context.updateDefinition(entityName, updatedDef),
-    deleteDefinition: () => context.deleteDefinition(entityName),
-    refresh: loadDefinitionDetails
-  };
-}
-
-// hooks/use-entity-record.ts
-import { useCallback as useCallback3, useEffect as useEffect3 } from "react";
-import { useDispatch as useDispatch2, useSelector as useSelector2 } from "react-redux";
-import { useNatsContext as useNatsContext2 } from "@elqnt/nats";
-
 // store/entity-record-slice.ts
 import { createSlice as createSlice2 } from "@reduxjs/toolkit";
 var initialState2 = {
@@ -638,343 +272,6 @@ var {
 } = entityRecordSlice.actions;
 var entityRecordReducer = entityRecordSlice.reducer;
 
-// hooks/use-entity-record.ts
-var defaultQuery = {
-  filters: {},
-  page: 1,
-  pageSize: 25,
-  sortBy: "metadata.createdAt",
-  sortOrder: -1
-};
-function useEntityRecord(orgId, entityName, options = {}) {
-  const { autoLoad = true } = options;
-  const { natsConnected, request } = useNatsContext2();
-  const dispatch = useDispatch2();
-  const recordState = useSelector2(
-    (state) => state.entityRecord.records[entityName] || {
-      items: {},
-      params: defaultQuery,
-      meta: {
-        items: [],
-        totalCount: 0,
-        currentPage: 1,
-        pageSize: 25,
-        totalPages: 0
-      },
-      selected: []
-    }
-  );
-  const selectedRecord = useSelector2(
-    (state) => state.entityRecord.selectedRecord
-  );
-  const isLoading = useSelector2(
-    (state) => state.entityRecord.isLoading
-  );
-  const loadingStates = useSelector2(
-    (state) => state.entityRecord.loadingStates
-  );
-  const error = useSelector2(
-    (state) => state.entityRecord.error
-  );
-  const loadRecords = useCallback3(
-    async (params) => {
-      if (!natsConnected || !orgId) return;
-      const loadingKey = `load_${entityName}`;
-      if (loadingStates[loadingKey]) return;
-      dispatch(setOperationLoading2({ operation: loadingKey, loading: true }));
-      try {
-        const queryParams = { ...recordState.params, ...params };
-        const response = await request(
-          EntityRecordQuery,
-          {
-            orgId,
-            entityName,
-            query: queryParams
-          }
-        );
-        if (response instanceof Error) {
-          dispatch(setError2(response.message));
-        } else if (response.records) {
-          dispatch(
-            setRecords({
-              entityName,
-              records: response.records,
-              params: queryParams
-            })
-          );
-        }
-      } catch (err) {
-        dispatch(
-          setError2(err instanceof Error ? err.message : "Unknown error")
-        );
-      } finally {
-        dispatch(
-          setOperationLoading2({ operation: loadingKey, loading: false })
-        );
-      }
-    },
-    [natsConnected, orgId, entityName, recordState.params, dispatch, request]
-  );
-  const loadRecord = useCallback3(
-    async (recordId) => {
-      if (!natsConnected || !orgId) return;
-      const loadingKey = `load_${recordId}`;
-      if (loadingStates[loadingKey]) return;
-      dispatch(setOperationLoading2({ operation: loadingKey, loading: true }));
-      try {
-        const response = await request(EntityRecordGet, { entityName, recordId, orgId }, {});
-        if (response instanceof Error) {
-          dispatch(setError2(response.message));
-          return;
-        }
-        dispatch(setSelectedRecord({ record: response.record }));
-      } finally {
-        dispatch(
-          setOperationLoading2({ operation: loadingKey, loading: false })
-        );
-      }
-    },
-    [natsConnected, orgId, entityName, recordState.params, dispatch, request]
-  );
-  const createRecord = async (record) => {
-    if (!natsConnected || !orgId) {
-      throw new Error("Not connected or missing orgId");
-    }
-    dispatch(
-      setOperationLoading2({ operation: "create_record", loading: true })
-    );
-    try {
-      const response = await request(
-        EntityRecordCreate,
-        {
-          orgId,
-          entityName,
-          record
-        }
-      );
-      if (response instanceof Error) {
-        throw response;
-      }
-      if (response.metadata.success) {
-        dispatch(addRecord({ entityName, record: response.record }));
-      }
-      loadRecords();
-      return response;
-    } finally {
-      dispatch(
-        setOperationLoading2({ operation: "create_record", loading: false })
-      );
-    }
-  };
-  const updateRecordById = async (record) => {
-    if (!natsConnected || !orgId) {
-      throw new Error("Not connected or missing orgId");
-    }
-    dispatch(
-      setOperationLoading2({ operation: `update_${record.id}`, loading: true })
-    );
-    try {
-      const response = await request(
-        EntityRecordUpdate,
-        {
-          orgId,
-          entityName,
-          record,
-          recordId: record.id
-        }
-      );
-      if (response instanceof Error) {
-        throw response;
-      }
-      dispatch(updateRecord({ entityName, record: response.record }));
-      return response;
-    } finally {
-      dispatch(
-        setOperationLoading2({
-          operation: `update_${record.id}`,
-          loading: false
-        })
-      );
-    }
-  };
-  const deleteRecordById = async (recordId) => {
-    if (!natsConnected || !orgId) {
-      throw new Error("Not connected or missing orgId");
-    }
-    dispatch(
-      setOperationLoading2({ operation: `delete_${recordId}`, loading: true })
-    );
-    try {
-      const response = await request(
-        EntityRecordDelete,
-        {
-          orgId,
-          entityName,
-          recordId
-        }
-      );
-      if (response instanceof Error) {
-        throw response;
-      }
-      dispatch(removeRecord({ entityName, recordId }));
-      return response;
-    } finally {
-      dispatch(
-        setOperationLoading2({ operation: `delete_${recordId}`, loading: false })
-      );
-    }
-  };
-  const countRecords = async (filters) => {
-    if (!natsConnected || !orgId) {
-      throw new Error("Not connected or missing orgId");
-    }
-    try {
-      const response = await request(
-        EntityRecordCount,
-        {
-          orgId,
-          entityName,
-          filters: filters || {}
-        }
-      );
-      if (response instanceof Error) {
-        throw response;
-      }
-      if (!response.metadata?.success) {
-        throw new Error(response.metadata?.error || "Failed to count records");
-      }
-      return response.count || 0;
-    } catch (err) {
-      console.error("Error counting records:", err);
-      return 0;
-    }
-  };
-  const getEntityRecordById = async (recordId) => {
-    if (!natsConnected || !orgId) {
-      throw new Error("Not connected or missing orgId");
-    }
-    try {
-      const response = await request(EntityRecordGet, { entityName, recordId, orgId }, {});
-      if (response instanceof Error) {
-        console.error("Error fetching record:", response.message);
-        return null;
-      }
-      return response.record || null;
-    } catch (error2) {
-      console.error("Error in getEntityRecordById:", error2);
-      return null;
-    }
-  };
-  const selectRecords = (ids) => {
-    dispatch(setSelected({ entityName, ids }));
-  };
-  const clearSelection = () => {
-    dispatch(setSelected({ entityName, ids: [] }));
-  };
-  const updateParams = (params) => {
-    console.log("updating query params", params);
-    dispatch(updateQueryParams({ entityName, params }));
-    loadRecords(params);
-  };
-  const refresh = useCallback3(() => {
-    loadRecords();
-  }, [loadRecords]);
-  useEffect3(() => {
-    let mounted = true;
-    if (autoLoad && natsConnected && orgId && mounted) {
-      loadRecords();
-    }
-    return () => {
-      mounted = false;
-    };
-  }, [autoLoad, natsConnected, orgId]);
-  return {
-    // State
-    records: recordState.items,
-    params: recordState.params,
-    selected: recordState.selected,
-    selectedRecord,
-    isLoading,
-    loadingStates,
-    error,
-    // Operations
-    loadRecords,
-    createRecord,
-    updateRecord: updateRecordById,
-    deleteRecord: deleteRecordById,
-    loadRecord,
-    countRecords,
-    getEntityRecordById,
-    // Selection
-    selectRecords,
-    clearSelection,
-    // Query
-    updateParams,
-    refresh
-  };
-}
-
-// hooks/use-debounce.ts
-import { useCallback as useCallback4, useRef } from "react";
-function useDebounce(callback, delay) {
-  const timerRef = useRef(null);
-  return useCallback4((...args) => {
-    if (timerRef.current) {
-      clearTimeout(timerRef.current);
-    }
-    timerRef.current = setTimeout(() => {
-      callback(...args);
-    }, delay);
-  }, [callback, delay]);
-}
-
-// context/entity-definition-context.tsx
-import { jsx } from "react/jsx-runtime";
-var EntityDefinitionContext = createContext(void 0);
-function EntityDefinitionProvider({
-  children,
-  orgId,
-  entityName,
-  options = {}
-}) {
-  const hookValue = useEntityDefinition(orgId, entityName, options);
-  const value = useMemo(() => hookValue, [hookValue]);
-  return /* @__PURE__ */ jsx(EntityDefinitionContext.Provider, { value, children });
-}
-function useEntityDefinitionContext() {
-  const context = useContext(EntityDefinitionContext);
-  if (!context) {
-    throw new Error(
-      "useEntityDefinitionContext must be used within an EntityDefinitionProvider"
-    );
-  }
-  return context;
-}
-
-// context/entity-record-context.tsx
-import { createContext as createContext2, useContext as useContext2, useMemo as useMemo2 } from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
-var EntityRecordContext = createContext2(void 0);
-function EntityRecordProvider({
-  children,
-  orgId,
-  entityName,
-  options = {}
-}) {
-  const hookValue = useEntityRecord(orgId, entityName, options);
-  const value = useMemo2(() => hookValue, [hookValue]);
-  return /* @__PURE__ */ jsx2(EntityRecordContext.Provider, { value, children });
-}
-function useEntityRecordContext() {
-  const context = useContext2(EntityRecordContext);
-  if (!context) {
-    throw new Error(
-      "useEntityRecordContext must be used within an EntityRecordProvider"
-    );
-  }
-  return context;
-}
-
 // consts/colors.ts
 var PREDEFINED_COLORS = [
   { value: "#EF4444", name: "Red" },
@@ -987,7 +284,6 @@ var PREDEFINED_COLORS = [
   { value: "#A855F7", name: "Purple" }
 ];
 export {
-  EntityDefinitionContext,
   EntityDefinitionCreate,
   EntityDefinitionCreated,
   EntityDefinitionDelete,
@@ -995,7 +291,6 @@ export {
   EntityDefinitionGet,
   EntityDefinitionGetServer,
   EntityDefinitionList,
-  EntityDefinitionProvider,
   EntityDefinitionUpdate,
   EntityDefinitionUpdated,
   EntityFieldTypeBool,
@@ -1021,14 +316,12 @@ export {
   EntityFilterOperators,
   EntityOrgSchemaCreate,
   EntityOrgSchemaDrop,
-  EntityRecordContext,
   EntityRecordCount,
   EntityRecordCreate,
   EntityRecordCreated,
   EntityRecordDelete,
   EntityRecordDeleted,
   EntityRecordGet,
-  EntityRecordProvider,
   EntityRecordQuery,
   EntityRecordUpdate,
   EntityRecordUpdated,
@@ -1064,12 +357,6 @@ export {
   RecordChangeActionDeleted,
   RecordChangeActionUpdated,
   entityDefinitionReducer,
-  entityRecordReducer,
-  useDebounce,
-  useEntityDefinition,
-  useEntityDefinitionContext,
-  useEntityDefinitionDetails,
-  useEntityRecord,
-  useEntityRecordContext
+  entityRecordReducer
 };
 //# sourceMappingURL=index.mjs.map