@sarafapp/iron_core 1.0.64 → 1.0.66

package/src/baseTable/moduleConnection/generator/GTable.ts

@@ -1,11 +0,0 @@
-import { TableSource } from "../../generator/TableSource";
-
-export function GTable<T>(table: new (...args: any[]) => TableSource<T>) {
-  return function GTableDecorator(constructor: Function) {
-    async function loadHeaderSchema() {
-      return constructor.prototype.headers || [];
-    }
-
-    (table as any).prototype.loadHeaderSchema = loadHeaderSchema;
-  };
-}

package/src/composables/UseCrud.ts

@@ -1,53 +0,0 @@
-import { computed, type Ref, ref } from 'vue'
-import type { BaseModel } from '../BaseModel'
-
-export function useCrud<Entity extends BaseModel>() {
-  const entityItems: Ref<Map<string, Entity>> = ref(new Map<string, Entity>()) as Ref<Map<string, Entity>>
-  const totalCount = ref<number>(0);
-
-  const getTotalCount = computed<number>(() => {
-    return totalCount.value;
-  })
-
-  const entityItemsAsArray = computed<Entity[]>(() => {
-    return Array.from(entityItems.value.values()) as Entity[]
-  })
-
-  function setTotalCount(count: number) {
-    totalCount.value = count;
-  }
-
-  function addOrReplaceItems(items: Entity[]) {
-    for (const item of items) {
-      addOrReplaceItem(item)
-    }
-  }
-
-  function addOrReplaceItem(item: Entity) {
-    entityItems.value.set(String(item.id), item as Entity)
-  }
-
-  function removeById(id: string | number) {
-    const itemToRemove = getItemById(id)
-    entityItems.value.delete(String(id))
-    return itemToRemove
-  }
-
-  function getItemById(id: number | string) {
-    return entityItems.value.get(String(id)) || null
-  }
-
-  function clearItems() {
-    entityItems.value.clear()
-  }
-
-  return {
-    entityItemsAsArray,
-    addOrReplaceItems,
-    removeById,
-    getItemById,
-    clearItems,
-    setTotalCount,
-    getTotalCount
-  }
-}

package/src/composables/UseData.ts

@@ -1,70 +0,0 @@
-import { computed, type Ref, ref } from "vue";
-import { BaseModel } from "../BaseModel";
-import type { Nullable } from "../types";
-
-export function useData<Model extends BaseModel>() {
-  const items: Ref<Map<number, Model>> = ref<Map<number, Model>>(
-    new Map<number, Model>(),
-  ) as Ref<Map<number, Model>>;
-
-  const totalCount = ref<number>(0);
-  const currentItem = ref<Nullable<Model>>(null);
-
-  const itemsAsArray = computed<Model[]>(() => {
-    return Array.from(items.value.values()) as Model[];
-  });
-
-  function setTotalCount(totalItems: number) {
-    totalCount.value = totalItems;
-  }
-
-  function addOrReplaceItems(itemsToAdd: Model[]) {
-    for (const item of itemsToAdd) {
-      addOrReplaceItem(item);
-    }
-  }
-
-  function addOrReplaceItem(item: Model) {
-    items.value.set(item.id, item);
-  }
-
-  function getById(id: number): Nullable<Model> {
-    currentItem.value = items.value.get(id) || null;
-    return currentItem.value;
-  }
-
-  function removeById(id: number): boolean {
-    const removedItem = getById(id);
-
-    if (removedItem) {
-      items.value.delete(id);
-    }
-
-    return Boolean(removedItem);
-  }
-
-  function clearItems() {
-    items.value.clear();
-  }
-
-  function setCurrentItem(item: Nullable<Model>) {
-    currentItem.value = item;
-  }
-
-  function clearCurrentItem() {
-    currentItem.value = null;
-  }
-
-  return {
-    itemsAsArray,
-    totalCount,
-    currentItem,
-    setTotalCount,
-    addOrReplaceItems,
-    getById,
-    removeById,
-    clearItems,
-    setCurrentItem,
-    clearCurrentItem,
-  };
-}

package/src/composables/UseLoadingStatus.ts

@@ -1,65 +0,0 @@
-import { computed, ref } from "vue";
-import { LoadingStatus } from "../constants";
-
-export function useLoadingStatus() {
-  const loadingStatus = ref<Set<LoadingStatus>>(new Set<LoadingStatus>());
-
-  const isFetchingList = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.FetchList);
-  });
-
-  const isFetchingItem = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.FetchItem);
-  });
-
-  const isFetchingLastItems = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.FetchLastItems);
-  });
-
-  const isFetchingPreviousItems = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.FetchPreviousItems);
-  });
-
-  const isCreating = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.Create);
-  });
-
-  const isUpdating = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.Update);
-  });
-
-  const isDeleting = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.Delete);
-  });
-
-  const isSearching = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.Search);
-  });
-
-  const isSorting = computed(() => {
-    return loadingStatus.value.has(LoadingStatus.Sort);
-  });
-
-  function setStatus(status: LoadingStatus) {
-    loadingStatus.value.add(status);
-  }
-
-  function removeStatus(status: LoadingStatus) {
-    loadingStatus.value.delete(status);
-  }
-
-  return {
-    loadingStatus,
-    isFetchingList,
-    isFetchingItem,
-    isFetchingLastItems,
-    isFetchingPreviousItems,
-    isCreating,
-    isUpdating,
-    isDeleting,
-    isSearching,
-    isSorting,
-    setStatus,
-    removeStatus,
-  };
-}

package/src/composables/UseParams.ts

@@ -1,93 +0,0 @@
-import { type Ref, ref } from "vue";
-import { SortDetail } from "../sort";
-import { BaseModel } from "../BaseModel";
-import { Params } from "../repository";
-
-const DEFAULT_PARAMS = new Params();
-
-export function useParams() {
-  const params: Ref<Params> = ref(structuredClone(DEFAULT_PARAMS));
-
-  function setNextPage() {
-    params.value.pageNumber = params.value.pageNumber + 1;
-  }
-
-  function setPreventPage() {
-    params.value.pageNumber = params.value.pageNumber - 1;
-  }
-
-  function setPageNumber(pageNumber: number) {
-    params.value.pageNumber = pageNumber;
-  }
-
-  function setItemCount(itemCount: number) {
-    params.value.itemCount = itemCount;
-  }
-
-  function setSortDetail(sortDetail: SortDetail<BaseModel>) {
-    params.value.sortDetail.key = sortDetail.key;
-    params.value.sortDetail.order = sortDetail.order;
-  }
-
-  function setFiltersBaseOnRequestBody(filters: Record<string, unknown>) {
-    for (const key in filters) {
-      setFilter(key, filters[key]);
-    }
-  }
-
-  function setFilter(key: string, value: unknown) {
-    const index = params.value.filters.findIndex(
-      (filter) => filter.key === key,
-    );
-    if (index > -1) params.value.filters[index].value = value;
-    else params.value.filters.push({ key, value });
-  }
-
-  function removeFilter(key: string) {
-    let currentParams = params.value.filters;
-    currentParams = currentParams.filter(iteratedParam => iteratedParam.key !== key)
-    params.value.filters = currentParams;
-  }
-
-  function getRequestParams() {
-    const requestParams: Record<string, unknown> = {
-      page: params.value.pageNumber,
-      count: params.value.itemCount,
-    };
-    if (params.value.sortDetail) {
-      requestParams.by = params.value.sortDetail.key;
-      requestParams.order = params.value.sortDetail.order;
-    }
-    for (const filter of params.value.filters) {
-      if (filter.value) {
-        if (typeof filter.value === 'string' || typeof filter.value === 'number') {
-          requestParams[filter.key] = filter.value;
-        } else {
-          const value = JSON.stringify(filter.value);
-          if (value !== "[]" && value !== "{}") {
-            requestParams[filter.key] = value;
-          }
-        }
-      }
-    }
-    return requestParams;
-  }
-
-  function clearParam() {
-    params.value = structuredClone(DEFAULT_PARAMS);
-  }
-
-  return {
-    params,
-    setNextPage,
-    setPreventPage,
-    setPageNumber,
-    setItemCount,
-    setSortDetail,
-    setFilter,
-    removeFilter,
-    getRequestParams,
-    clearParam,
-    setFiltersBaseOnRequestBody
-  };
-}

package/src/composables/UseRepository.ts

@@ -1,207 +0,0 @@
-import { computed, onBeforeUnmount } from "vue";
-import { useData } from "./UseData";
-import { useParams } from "./UseParams";
-import { useLoadingStatus } from "./UseLoadingStatus";
-import { type Repository, type SyncDetail } from "../repository";
-import { LoadingStatus } from "../constants";
-import { SortDetail } from "../sort";
-import { BaseModel } from "../BaseModel";
-import { Scheduler } from "../baseSchedule";
-import { type TableRenderingData, type TableService } from "../baseTable";
-
-export function useRepository<Model extends BaseModel>(
-  repository: Repository<Model>,
-) {
-  const dataManger = useData();
-  const paramsManager = useParams();
-  const loadingStatusManager = useLoadingStatus();
-
-  const scheduler = new Scheduler({
-    runAction: async () => fetchList(LoadingStatus.AutoRefresh),
-  });
-
-  const currentPageItems = computed<Model[]>(() => {
-    const pageNumber = paramsManager.params.value.pageNumber;
-    const pageSize = paramsManager.params.value.itemCount;
-    const startIndex = pageNumber * pageSize - pageSize;
-    const endIndex = pageNumber * pageSize - 1;
-    const items: Model[] = [];
-    for (let index = startIndex; index <= endIndex; index++) {
-      if (!dataManger.itemsAsArray.value[index]) break;
-      items.push(dataManger.itemsAsArray.value[index] as Model);
-    }
-    return items;
-  });
-
-  const tableRenderingData = computed<TableRenderingData<Model>>(() => {
-    return {
-      totalItems: dataManger.totalCount.value,
-      currentPage: paramsManager.params.value.pageNumber,
-      rows: dataManger.itemsAsArray.value,
-      loadingStatus: loadingStatusManager.loadingStatus.value,
-      currentPageItems: currentPageItems.value,
-    } as TableRenderingData<Model>;
-  });
-
-  const tableService = computed<TableService<Model>>(() => {
-    return {
-      getData: getTableRenderingData,
-      sort: sort,
-      paginate: fetchItemsByPageNumber,
-      fetchRows: fetchList,
-    };
-  });
-
-  const syncDetail = computed<SyncDetail>(() => {
-    return repository.getSyncDetail();
-  });
-
-  function getTableRenderingData(): TableRenderingData<Model> {
-    return tableRenderingData.value;
-  }
-
-  async function handleFetchList(query?: Record<string, unknown>) {
-    const result = await repository.fetchList(query);
-    dataManger.clearItems();
-    dataManger.addOrReplaceItems(result.items);
-    dataManger.setTotalCount(result.totalItems);
-    return result;
-  }
-
-  async function fetchList(
-    loadingStatus: LoadingStatus = LoadingStatus.FetchList,
-  ) {
-    loadingStatusManager.setStatus(loadingStatus);
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(loadingStatus);
-    return result;
-  }
-
-  async function fetchWithAutoRefresh() {
-    setupAutoRefresh();
-    await fetchList();
-  }
-
-  function setupAutoRefresh() {
-    if (!syncDetail.value.shouldKeepSync) {
-      throw new Error(`The provided repository does not support auto refresh`);
-    }
-    scheduler.setupInterval(syncDetail.value.intervalInMillisecond);
-  }
-
-  function stopAutoRefresh() {
-    scheduler.clearInterval();
-  }
-
-  async function fetchItemById(id: number, shouldRemoveItem = true) {
-    loadingStatusManager.setStatus(LoadingStatus.FetchItem);
-    if (shouldRemoveItem) {
-      dataManger.clearCurrentItem();
-    }
-    const result = await repository.fetchItemById(id);
-    dataManger.setCurrentItem(result);
-    loadingStatusManager.removeStatus(LoadingStatus.FetchItem);
-    return result;
-  }
-
-  async function createItem<Body>(body: Body) {
-    loadingStatusManager.setStatus(LoadingStatus.Create);
-    const result = await repository.createItem(body);
-    if (result) {
-      dataManger.addOrReplaceItems([result]);
-    }
-    loadingStatusManager.removeStatus(LoadingStatus.Create);
-    return result;
-  }
-
-  async function updateItem<Body>(id: number, body: Body) {
-    loadingStatusManager.setStatus(LoadingStatus.Update);
-    const result = await repository.updateItem(id, body);
-    if (result) {
-      dataManger.addOrReplaceItems([result]);
-    }
-    loadingStatusManager.removeStatus(LoadingStatus.Update);
-    return result;
-  }
-
-  async function deleteItem(id: number) {
-    loadingStatusManager.setStatus(LoadingStatus.Delete);
-    await repository.deleteItem(id);
-    loadingStatusManager.removeStatus(LoadingStatus.Delete);
-    return dataManger.removeById(id);
-  }
-
-  async function fetchLastItems() {
-    paramsManager.setNextPage();
-    loadingStatusManager.setStatus(LoadingStatus.FetchLastItems);
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(LoadingStatus.FetchLastItems);
-    return result;
-  }
-
-  async function fetchPreviousItems() {
-    paramsManager.setPreventPage();
-    loadingStatusManager.setStatus(LoadingStatus.FetchPreviousItems);
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(LoadingStatus.FetchPreviousItems);
-    return result;
-  }
-
-  async function fetchItemsByPageNumber(pageNumber: number) {
-    paramsManager.setPageNumber(pageNumber);
-    loadingStatusManager.setStatus(LoadingStatus.FetchList);
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(LoadingStatus.FetchList);
-    return result;
-  }
-
-  async function search(searchedValue: string) {
-    paramsManager.setFilter("search", searchedValue);
-    loadingStatusManager.setStatus(LoadingStatus.Search);
-    dataManger.clearItems();
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(LoadingStatus.Search);
-    return result;
-  }
-
-  async function sort(sortDetail: SortDetail<Model>) {
-    paramsManager.setSortDetail(sortDetail as SortDetail<BaseModel>);
-    loadingStatusManager.setStatus(LoadingStatus.Sort);
-    dataManger.clearItems();
-    const result = await handleFetchList(paramsManager.getRequestParams());
-    loadingStatusManager.removeStatus(LoadingStatus.Sort);
-    return result;
-  }
-
-  async function clearFilters() {
-    paramsManager.clearParam();
-    return await fetchList();
-  }
-
-  onBeforeUnmount(() => {
-    stopAutoRefresh();
-  });
-
-  return {
-    loadingStatusManager,
-    dataManger,
-    paramsManager,
-    tableRenderingData,
-    fetchList,
-    fetchWithAutoRefresh,
-    setupAutoRefresh,
-    stopAutoRefresh,
-    fetchItemById,
-    createItem,
-    updateItem,
-    deleteItem,
-    fetchLastItems,
-    fetchPreviousItems,
-    fetchItemsByPageNumber,
-    search,
-    sort,
-    clearFilters,
-    tableService,
-    currentPageItems,
-  };
-}

package/src/composables/UseState.ts

@@ -1,30 +0,0 @@
-import { computed, ref, type Ref } from "vue";
-
-export function useState<T>(initial: T, ttl: number = 300_000): Ref<T> {
-  const state = ref<T>(structuredClone(initial));
-  let timer: ReturnType<typeof setTimeout> | null = null;
-
-  function resetTimer() {
-    if (timer) clearTimeout(timer);
-    if (ttl > 0) {
-      timer = setTimeout(() => {
-        state.value = initial;
-      }, ttl);
-    }
-  }
-
-  const computedState = computed<T>({
-    get() {
-      resetTimer();
-      return state.value;
-    },
-    set(value: T) {
-      state.value = value;
-      resetTimer();
-    },
-  });
-
-  resetTimer();
-
-  return computedState;
-}

package/src/composables/UseStaticTableService.ts

@@ -1,45 +0,0 @@
-import { computed, ref } from 'vue'
-import { LoadingStatus } from '../constants'
-import { SortDetail } from '../sort'
-import type { TableRenderingData, TableService } from '../baseTable'
-
-export function useStaticTableService<Model>(initialRows: Model[]) {
-  const tableRows = ref<Model[]>(initialRows);
-
-  const staticTableService = computed<TableService<Model>>(() => {
-    return {
-      getData(): TableRenderingData<Model> {
-        return {
-          totalItems: tableRows.value.length,
-          currentPageItems: tableRows.value as Model[],
-          loadingStatus: new Set<LoadingStatus>(),
-          rows: tableRows.value as Model[],
-          currentPage: 1
-        }
-      },
-      async sort(_sortDetail: SortDetail<Model>) {
-        return {
-          totalItems: tableRows.value.length,
-          items: tableRows.value as Model[]
-        }
-      },
-      async fetchRows() {
-        return {
-          totalItems: tableRows.value.length,
-          items: tableRows.value as Model[]
-        }
-      },
-      async paginate(_nextPage: number, _pageSize: number) {
-        return {
-          totalItems: tableRows.value.length,
-          items: tableRows.value as Model[]
-        }
-      }
-    }
-  })
-
-  return {
-    tableRows,
-    staticTableService
-  }
-}

package/src/composables/index.ts

@@ -1,7 +0,0 @@
-export { useRepository } from "./UseRepository";
-export { useData } from "./UseData";
-export { useParams } from "./UseParams";
-export { useLoadingStatus } from "./UseLoadingStatus";
-export { useStaticTableService } from "./UseStaticTableService";
-export * from "./UseCrud";
-export * from "./UseState";