@elqnt/entity 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1108 @@
+// 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";
+
+// models/entity.ts
+var OperatorEq = "eq";
+var OperatorNe = "ne";
+var OperatorGt = "gt";
+var OperatorGte = "gte";
+var OperatorLt = "lt";
+var OperatorLte = "lte";
+var OperatorIn = "in";
+var OperatorNin = "nin";
+var OperatorContains = "contains";
+var OperatorStartsWith = "startsWith";
+var OperatorEndsWith = "endsWith";
+var OperatorExists = "exists";
+var OperatorEmpty = "empty";
+var OperatorBetween = "between";
+var EntityFilterOperators = {
+  eq: { value: "eq", label: "Equal to" },
+  ne: { value: "ne", label: "Not equal to" },
+  gt: { value: "gt", label: "Greater than" },
+  gte: { value: "gte", label: "Greater than or equal to" },
+  lt: { value: "lt", label: "Less than" },
+  lte: { value: "lte", label: "Less than or equal to" },
+  in: { value: "in", label: "In" },
+  nin: { value: "nin", label: "Not in" },
+  contains: { value: "contains", label: "Contains" },
+  startsWith: { value: "startsWith", label: "Starts with" },
+  endsWith: { value: "endsWith", label: "Ends with" },
+  exists: { value: "exists", label: "Exists" },
+  empty: { value: "empty", label: "Empty" },
+  between: { value: "between", label: "Between" }
+};
+var EntityFieldTypeString = "string";
+var EntityFieldTypeStringMultiline = "stringMultiline";
+var EntityFieldTypeText = "text";
+var EntityFieldTypeInt = "int";
+var EntityFieldTypeFloat = "float";
+var EntityFieldTypeBool = "bool";
+var EntityFieldTypeDate = "date";
+var EntityFieldTypeDateTime = "datetime";
+var EntityFieldTypeEmail = "email";
+var EntityFieldTypePhone = "phone";
+var EntityFieldTypeURL = "url";
+var EntityFieldTypeDropdown = "dropdown";
+var EntityFieldTypeMultiSelect = "multiselect";
+var EntityFieldTypeLookup = "lookup";
+var EntityFieldTypeMultiLookup = "multilookup";
+var EntityFieldTypeCurrency = "currency";
+var EntityFieldTypeFile = "file";
+var EntityFieldTypeImage = "image";
+var EntityFieldTypeJSON = "json";
+var EntityFieldTypes = {
+  string: { value: "string", label: "Short Text" },
+  stringMultiline: { value: "stringMultiline", label: "Long Text" },
+  text: { value: "text", label: "Rich Text Editor" },
+  int: { value: "int", label: "Integer" },
+  float: { value: "float", label: "Decimal" },
+  bool: { value: "bool", label: "Boolean" },
+  date: { value: "date", label: "Date" },
+  datetime: { value: "datetime", label: "Date & Time" },
+  email: { value: "email", label: "Email" },
+  phone: { value: "phone", label: "Phone" },
+  url: { value: "url", label: "URL" },
+  dropdown: { value: "dropdown", label: "Dropdown" },
+  multiselect: { value: "multiselect", label: "Multi Select" },
+  lookup: { value: "lookup", label: "Lookup" },
+  multilookup: { value: "multilookup", label: "Multi Lookup" },
+  currency: { value: "currency", label: "Currency" },
+  file: { value: "file", label: "File" },
+  image: { value: "image", label: "Image" },
+  json: { value: "json", label: "JSON" }
+};
+var RecordChangeActionCreated = "created";
+var RecordChangeActionUpdated = "updated";
+var RecordChangeActionDeleted = "deleted";
+var EntityOrgSchemaCreate = "entity.org.schema.create";
+var EntityOrgSchemaDrop = "entity.org.schema.drop";
+var EntityDefinitionCreate = "entity.definition.create";
+var EntityDefinitionCreated = "entity.definition.created";
+var EntityDefinitionUpdate = "entity.definition.update";
+var EntityDefinitionGet = "entity.definition.get";
+var EntityDefinitionGetServer = "entity.definition.get.server";
+var EntityDefinitionList = "entity.definition.list";
+var EntityDefinitionUpdated = "entity.definition.updated";
+var EntityDefinitionDelete = "entity.definition.delete";
+var EntityDefinitionDeleted = "entity.definition.deleted";
+var EntityRecordCreate = "entity.record.create";
+var EntityRecordCreated = "entity.record.created";
+var EntityRecordGet = "entity.record.get";
+var EntityRecordQuery = "entity.record.query";
+var EntityRecordCount = "entity.record.count";
+var EntityRecordUpdate = "entity.record.update";
+var EntityRecordUpdated = "entity.record.updated";
+var EntityRecordDelete = "entity.record.delete";
+var EntityRecordDeleted = "entity.record.deleted";
+var EntityRecordsBulkCreate = "entity.records.bulk.create";
+var EntityRecordsBulkCreated = "entity.records.bulk.created";
+var EntityRecordsBulkUpdate = "entity.records.bulk.update";
+var EntityRecordsBulkUpdated = "entity.records.bulk.updated";
+var EntityRecordsBulkDelete = "entity.records.bulk.delete";
+var EntityRecordsBulkDeleted = "entity.records.bulk.deleted";
+var EntityViewCreate = "entity.view.create";
+var EntityViewCreated = "entity.view.created";
+var EntityViewUpdate = "entity.view.update";
+var EntityViewUpdated = "entity.view.updated";
+var EntityViewDelete = "entity.view.delete";
+var EntityViewDeleted = "entity.view.deleted";
+var EntityViewList = "entity.view.list";
+
+// store/entity-definition-slice.ts
+import { createSlice } from "@reduxjs/toolkit";
+var initialState = {
+  definitions: {},
+  views: {},
+  isLoading: false,
+  loadingStates: {}
+};
+var entityDefinitionSlice = createSlice({
+  name: "entityDefinition",
+  initialState,
+  reducers: {
+    setLoading: (state, action) => {
+      state.isLoading = action.payload;
+    },
+    setOperationLoading: (state, action) => {
+      state.loadingStates[action.payload.operation] = action.payload.loading;
+    },
+    setError: (state, action) => {
+      state.error = action.payload;
+    },
+    setDefinitions: (state, action) => {
+      state.definitions = action.payload.reduce(
+        (acc, def) => {
+          acc[def.name] = def;
+          return acc;
+        },
+        {}
+      );
+    },
+    addDefinition: (state, action) => {
+      const definition = action.payload;
+      state.definitions[definition.name] = definition;
+    },
+    updateDefinition: (state, action) => {
+      const definition = action.payload;
+      state.definitions[definition.name] = definition;
+      if (state.selectedDefinition?.name === definition.name) {
+        state.selectedDefinition = definition;
+      }
+    },
+    removeDefinition: (state, action) => {
+      delete state.definitions[action.payload];
+      if (state.selectedDefinition?.name === action.payload) {
+        state.selectedDefinition = void 0;
+      }
+    },
+    setSelectedDefinition: (state, action) => {
+      state.selectedDefinition = action.payload;
+    },
+    setViews: (state, action) => {
+      const { entityName, views } = action.payload;
+      state.views[entityName] = views;
+    },
+    addView: (state, action) => {
+      const { entityName, view } = action.payload;
+      if (!state.views[entityName]) {
+        state.views[entityName] = [];
+      }
+      state.views[entityName].push(view);
+    },
+    updateView: (state, action) => {
+      const { entityName, view } = action.payload;
+      const views = state.views[entityName];
+      if (views) {
+        const index = views.findIndex((v) => v.id === view.id);
+        if (index !== -1) {
+          views[index] = view;
+          if (state.selectedView?.id === view.id) {
+            state.selectedView = view;
+          }
+        }
+      }
+    },
+    removeView: (state, action) => {
+      const { entityName, viewId } = action.payload;
+      const views = state.views[entityName];
+      if (views) {
+        state.views[entityName] = views.filter((v) => v.id !== viewId);
+        if (state.selectedView?.id === viewId) {
+          state.selectedView = void 0;
+        }
+      }
+    },
+    setSelectedView: (state, action) => {
+      state.selectedView = action.payload;
+    }
+  }
+});
+var {
+  setLoading,
+  setOperationLoading,
+  setError,
+  setDefinitions,
+  addDefinition,
+  updateDefinition,
+  removeDefinition,
+  setSelectedDefinition,
+  setViews,
+  addView,
+  updateView,
+  removeView,
+  setSelectedView
+} = 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 = {
+  records: {},
+  isLoading: false,
+  loadingStates: {}
+};
+var entityRecordSlice = createSlice2({
+  name: "entityRecord",
+  initialState: initialState2,
+  reducers: {
+    setLoading: (state, action) => {
+      state.isLoading = action.payload;
+    },
+    setOperationLoading: (state, action) => {
+      state.loadingStates[action.payload.operation] = action.payload.loading;
+    },
+    setError: (state, action) => {
+      state.error = action.payload;
+    },
+    setRecords: (state, action) => {
+      const { entityName, records, params } = action.payload;
+      state.records[entityName] = {
+        items: records.items.reduce(
+          (acc, record) => {
+            acc[record.id] = record;
+            return acc;
+          },
+          {}
+        ),
+        params,
+        meta: records,
+        selected: []
+      };
+    },
+    addRecord: (state, action) => {
+      const { entityName, record } = action.payload;
+      if (state.records[entityName]) {
+        state.records[entityName].items[record.id] = record;
+      }
+    },
+    updateRecord: (state, action) => {
+      const { entityName, record } = action.payload;
+      if (state.records[entityName]) {
+        state.records[entityName].items[record.id] = record;
+      }
+    },
+    removeRecord: (state, action) => {
+      const { entityName, recordId } = action.payload;
+      if (state.records[entityName]) {
+        delete state.records[entityName].items[recordId];
+        state.records[entityName].selected = state.records[entityName].selected.filter((id) => id !== recordId);
+      }
+    },
+    setSelected: (state, action) => {
+      const { entityName, ids } = action.payload;
+      if (state.records[entityName]) {
+        state.records[entityName].selected = ids;
+      }
+    },
+    setActiveView: (state, action) => {
+      state.activeView = action.payload;
+    },
+    updateQueryParams: (state, action) => {
+      const { entityName, params } = action.payload;
+      if (state.records[entityName]) {
+        state.records[entityName].params = {
+          ...state.records[entityName].params,
+          ...params
+        };
+      }
+    },
+    setSelectedRecord: (state, action) => {
+      const { record } = action.payload;
+      state.selectedRecord = record;
+    }
+  }
+});
+var {
+  setLoading: setLoading2,
+  setOperationLoading: setOperationLoading2,
+  setError: setError2,
+  setRecords,
+  addRecord,
+  updateRecord,
+  removeRecord,
+  setSelected,
+  setSelectedRecord,
+  setActiveView,
+  updateQueryParams
+} = 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" },
+  { value: "#F97316", name: "Orange" },
+  { value: "#EAB308", name: "Yellow" },
+  { value: "#22C55E", name: "Green" },
+  { value: "#06B6D4", name: "Cyan" },
+  { value: "#3B82F6", name: "Blue" },
+  { value: "#6366F1", name: "Indigo" },
+  { value: "#A855F7", name: "Purple" }
+];
+export {
+  EntityDefinitionContext,
+  EntityDefinitionCreate,
+  EntityDefinitionCreated,
+  EntityDefinitionDelete,
+  EntityDefinitionDeleted,
+  EntityDefinitionGet,
+  EntityDefinitionGetServer,
+  EntityDefinitionList,
+  EntityDefinitionProvider,
+  EntityDefinitionUpdate,
+  EntityDefinitionUpdated,
+  EntityFieldTypeBool,
+  EntityFieldTypeCurrency,
+  EntityFieldTypeDate,
+  EntityFieldTypeDateTime,
+  EntityFieldTypeDropdown,
+  EntityFieldTypeEmail,
+  EntityFieldTypeFile,
+  EntityFieldTypeFloat,
+  EntityFieldTypeImage,
+  EntityFieldTypeInt,
+  EntityFieldTypeJSON,
+  EntityFieldTypeLookup,
+  EntityFieldTypeMultiLookup,
+  EntityFieldTypeMultiSelect,
+  EntityFieldTypePhone,
+  EntityFieldTypeString,
+  EntityFieldTypeStringMultiline,
+  EntityFieldTypeText,
+  EntityFieldTypeURL,
+  EntityFieldTypes,
+  EntityFilterOperators,
+  EntityOrgSchemaCreate,
+  EntityOrgSchemaDrop,
+  EntityRecordContext,
+  EntityRecordCount,
+  EntityRecordCreate,
+  EntityRecordCreated,
+  EntityRecordDelete,
+  EntityRecordDeleted,
+  EntityRecordGet,
+  EntityRecordProvider,
+  EntityRecordQuery,
+  EntityRecordUpdate,
+  EntityRecordUpdated,
+  EntityRecordsBulkCreate,
+  EntityRecordsBulkCreated,
+  EntityRecordsBulkDelete,
+  EntityRecordsBulkDeleted,
+  EntityRecordsBulkUpdate,
+  EntityRecordsBulkUpdated,
+  EntityViewCreate,
+  EntityViewCreated,
+  EntityViewDelete,
+  EntityViewDeleted,
+  EntityViewList,
+  EntityViewUpdate,
+  EntityViewUpdated,
+  OperatorBetween,
+  OperatorContains,
+  OperatorEmpty,
+  OperatorEndsWith,
+  OperatorEq,
+  OperatorExists,
+  OperatorGt,
+  OperatorGte,
+  OperatorIn,
+  OperatorLt,
+  OperatorLte,
+  OperatorNe,
+  OperatorNin,
+  OperatorStartsWith,
+  PREDEFINED_COLORS,
+  RecordChangeActionCreated,
+  RecordChangeActionDeleted,
+  RecordChangeActionUpdated,
+  entityDefinitionReducer,
+  entityRecordReducer,
+  useDebounce,
+  useEntityDefinition,
+  useEntityDefinitionContext,
+  useEntityDefinitionDetails,
+  useEntityRecord,
+  useEntityRecordContext
+};
+//# sourceMappingURL=index.mjs.map