@web-ts-toolkit/access-router-react 0.5.0

package/index.js

@@ -0,0 +1,610 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createModelHooks: () => createModelHooks
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/create-model-hook.ts
+var import_react2 = require("react");
+
+// src/fetch.ts
+var import_react = require("react");
+function isAbortError(err) {
+  return err instanceof DOMException && err.name === "AbortError";
+}
+function useAbortManager() {
+  const ref = (0, import_react.useRef)(null);
+  const replace = (0, import_react.useCallback)((next) => {
+    ref.current?.abort();
+    ref.current = next;
+  }, []);
+  (0, import_react.useEffect)(() => {
+    return () => {
+      ref.current?.abort();
+      ref.current = null;
+    };
+  }, []);
+  return { replace };
+}
+function stableStringify(value) {
+  if (value == null) return "";
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",")}}`;
+}
+function useMountRef() {
+  const ref = (0, import_react.useRef)(true);
+  (0, import_react.useEffect)(() => {
+    ref.current = true;
+    return () => {
+      ref.current = false;
+    };
+  }, []);
+  return ref;
+}
+
+// src/create-model-hook.ts
+function useAutoQuery({
+  doFetch,
+  applyResult,
+  shouldFetch,
+  deps,
+  onSuccess,
+  onError,
+  onSettled
+}) {
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
+  const [isFetching, setIsFetching] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const manager = useAbortManager();
+  const mountRef = useMountRef();
+  const fetchAndSet = (0, import_react2.useCallback)(
+    async (signal) => {
+      setIsFetching(true);
+      setError(null);
+      try {
+        return await doFetch(signal);
+      } catch (err) {
+        if (!isAbortError(err)) setError(err);
+        throw err;
+      } finally {
+        if (!signal?.aborted) setIsFetching(false);
+      }
+    },
+    [doFetch]
+  );
+  const doFetchWithCallbacks = (0, import_react2.useCallback)(
+    async (signal) => {
+      const res = await fetchAndSet(signal);
+      if (!signal?.aborted) {
+        applyResult(res);
+        onSuccess?.(res);
+        onSettled?.(res, null);
+      }
+      return res;
+    },
+    [fetchAndSet, applyResult, onSuccess, onSettled]
+  );
+  (0, import_react2.useEffect)(() => {
+    if (!shouldFetch) return;
+    mountRef.current = true;
+    setIsLoading(true);
+    const controller = new AbortController();
+    manager.replace(controller);
+    doFetchWithCallbacks(controller.signal).catch((err) => {
+      if (!mountRef.current || controller.signal.aborted) return;
+      onError?.(err);
+      onSettled?.(null, err);
+    }).finally(() => {
+      if (mountRef.current && !controller.signal.aborted) setIsLoading(false);
+    });
+    return () => {
+      mountRef.current = false;
+      controller.abort();
+    };
+  }, deps);
+  const refetch = (0, import_react2.useCallback)(() => {
+    setIsLoading(true);
+    const controller = new AbortController();
+    manager.replace(controller);
+    doFetchWithCallbacks(controller.signal).catch(() => {
+    }).finally(() => {
+      if (!controller.signal.aborted) setIsLoading(false);
+    });
+  }, [doFetchWithCallbacks, manager]);
+  return { isLoading, isFetching, error, setError, refetch, manager, mountRef };
+}
+function useMutation(execute, options) {
+  const [isPending, setIsPending] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const mountRef = useMountRef();
+  const { onSuccess, onSettled } = options ?? {};
+  const executeMutate = (0, import_react2.useCallback)(
+    async (...args) => {
+      setIsPending(true);
+      setError(null);
+      try {
+        const result = await execute(...args);
+        if (mountRef.current) {
+          onSuccess?.(result);
+          onSettled?.(result, null);
+        }
+        return result;
+      } catch (err) {
+        const svcErr = err;
+        if (mountRef.current) {
+          setError(svcErr);
+          onSettled?.(null, svcErr);
+        }
+        throw svcErr;
+      } finally {
+        if (mountRef.current) setIsPending(false);
+      }
+    },
+    [execute, mountRef, onSuccess, onSettled]
+  );
+  const reset = (0, import_react2.useCallback)(() => setError(null), []);
+  return { isPending, error, executeMutate, reset };
+}
+function createModelHooks(config) {
+  const { modelService } = config;
+  function useRead(options = {}) {
+    const {
+      id,
+      advanced,
+      select,
+      populate,
+      sort,
+      include,
+      tasks,
+      basicOptions,
+      advancedOptions,
+      enabled = true,
+      initialData = null,
+      requestConfig,
+      onSuccess,
+      onError,
+      onSettled
+    } = options;
+    const [data, setData] = (0, import_react2.useState)(initialData);
+    const applyResult = (0, import_react2.useCallback)((res) => {
+      setData(res.data);
+    }, []);
+    const doFetchById = (0, import_react2.useCallback)(
+      async (targetId, signal) => {
+        if (advanced) {
+          return await modelService.readAdvanced(
+            targetId,
+            { select, populate, sort, include, tasks },
+            advancedOptions,
+            { ...requestConfig, signal }
+          ).exec();
+        }
+        return await modelService.read(targetId, basicOptions, { ...requestConfig, signal }).exec();
+      },
+      [modelService, advanced, select, populate, sort, include, tasks, basicOptions, advancedOptions, requestConfig]
+    );
+    const doFetch = (0, import_react2.useCallback)(
+      (signal) => {
+        if (!id) throw new Error("useRead: id is required");
+        return doFetchById(id, signal);
+      },
+      [doFetchById, id]
+    );
+    const shouldFetch = Boolean(id && enabled);
+    const { isLoading, isFetching, error, refetch } = useAutoQuery({
+      doFetch,
+      applyResult,
+      shouldFetch,
+      deps: [id, enabled, advanced, select, populate, sort, include, tasks, basicOptions, advancedOptions],
+      onSuccess,
+      onError,
+      onSettled
+    });
+    const query = (0, import_react2.useCallback)(
+      async (readId) => {
+        const res = await doFetchById(readId);
+        applyResult(res);
+        onSuccess?.(res);
+        onSettled?.(res, null);
+        return res;
+      },
+      [doFetchById, applyResult, onSuccess, onSettled]
+    );
+    const reset = (0, import_react2.useCallback)(() => {
+      setData(initialData);
+    }, [initialData]);
+    return { data, isLoading, isFetching, error, query, refetch, reset };
+  }
+  function useList(options = {}) {
+    const {
+      listParams,
+      filter,
+      advanced,
+      sort,
+      select,
+      populate,
+      include,
+      tasks,
+      basicOptions,
+      advancedOptions,
+      enabled = true,
+      keepPreviousData = false,
+      initialData,
+      requestConfig,
+      onSuccess,
+      onError,
+      onSettled
+    } = options;
+    const [data, setData] = (0, import_react2.useState)(initialData ?? []);
+    const [previousData, setPreviousData] = (0, import_react2.useState)(void 0);
+    const [totalCount, setTotalCount] = (0, import_react2.useState)(0);
+    const latestDataRef = (0, import_react2.useRef)(data);
+    latestDataRef.current = data;
+    const applyResult = (0, import_react2.useCallback)((res) => {
+      setData(res.data);
+      setTotalCount(res.totalCount);
+      setPreviousData(void 0);
+    }, []);
+    const baseFetch = (0, import_react2.useCallback)(
+      async (args, signal) => {
+        if (keepPreviousData) {
+          setPreviousData(latestDataRef.current);
+        }
+        if (advanced) {
+          return await modelService.listAdvanced(
+            filter ?? {},
+            { sort, select, populate, include, tasks, ...args },
+            advancedOptions,
+            { ...requestConfig, signal }
+          ).exec();
+        }
+        return await modelService.list(args ?? listParams, basicOptions, { ...requestConfig, signal }).exec();
+      },
+      [
+        modelService,
+        advanced,
+        filter,
+        sort,
+        select,
+        populate,
+        include,
+        tasks,
+        listParams,
+        basicOptions,
+        advancedOptions,
+        requestConfig,
+        keepPreviousData,
+        latestDataRef
+      ]
+    );
+    const doFetch = (0, import_react2.useCallback)((signal) => baseFetch(listParams, signal), [baseFetch, listParams]);
+    const listParamsKey = stableStringify(listParams);
+    const filterKey = stableStringify(filter);
+    const sortKey = stableStringify(sort);
+    const shouldFetch = Boolean((listParams || advanced) && enabled);
+    const { isLoading, isFetching, error, refetch } = useAutoQuery({
+      doFetch,
+      applyResult,
+      shouldFetch,
+      deps: [
+        listParamsKey,
+        filterKey,
+        advanced,
+        enabled,
+        select,
+        populate,
+        sortKey,
+        include,
+        tasks,
+        basicOptions,
+        advancedOptions
+      ],
+      onSuccess,
+      onError,
+      onSettled
+    });
+    const query = (0, import_react2.useCallback)(
+      async (args) => {
+        const res = await baseFetch(args);
+        applyResult(res);
+        onSuccess?.(res);
+        onSettled?.(res, null);
+        return res;
+      },
+      [baseFetch, applyResult, onSuccess, onSettled]
+    );
+    const reset = (0, import_react2.useCallback)(() => {
+      setData(initialData ?? []);
+      setPreviousData(void 0);
+      setTotalCount(0);
+    }, [initialData]);
+    return { data, previousData, totalCount, isLoading, isFetching, error, query, refetch, reset };
+  }
+  function useCreate(options = {}) {
+    const {
+      advanced,
+      select,
+      populate,
+      tasks,
+      basicOptions,
+      advancedOptions,
+      requestConfig,
+      onSuccess,
+      onError,
+      onSettled
+    } = options;
+    const [data, setData] = (0, import_react2.useState)(null);
+    const mountRef = useMountRef();
+    const execute = (0, import_react2.useCallback)(
+      async (createData) => {
+        let res;
+        if (advanced) {
+          res = await modelService.createAdvanced(
+            createData,
+            { select, populate, tasks },
+            advancedOptions,
+            requestConfig
+          ).exec();
+        } else {
+          res = await modelService.create(createData, basicOptions, requestConfig).exec();
+        }
+        if (mountRef.current) setData(res.data);
+        return res;
+      },
+      [modelService, advanced, select, populate, tasks, basicOptions, advancedOptions, requestConfig, mountRef]
+    );
+    const { isPending, error, executeMutate, reset: resetError } = useMutation(execute, { onSuccess, onSettled });
+    const mutate = (0, import_react2.useCallback)(
+      async (createData) => {
+        try {
+          return await executeMutate(createData);
+        } catch (err) {
+          onError?.(err);
+          throw err;
+        }
+      },
+      [executeMutate, onError]
+    );
+    const reset = (0, import_react2.useCallback)(() => {
+      setData(null);
+      resetError();
+    }, [resetError]);
+    return { data, isPending, error, mutate, reset };
+  }
+  function useUpdate(options = {}) {
+    const {
+      advanced,
+      select,
+      populate,
+      tasks,
+      basicOptions,
+      advancedOptions,
+      requestConfig,
+      onSuccess,
+      onError,
+      onSettled
+    } = options;
+    const [data, setData] = (0, import_react2.useState)(null);
+    const mountRef = useMountRef();
+    const execute = (0, import_react2.useCallback)(
+      async (updateId, updateData) => {
+        let res;
+        if (advanced) {
+          res = await modelService.updateAdvanced(
+            updateId,
+            updateData,
+            { select, populate, tasks },
+            advancedOptions,
+            requestConfig
+          ).exec();
+        } else {
+          res = await modelService.update(updateId, updateData, basicOptions, requestConfig).exec();
+        }
+        if (mountRef.current) setData(res.data);
+        return res;
+      },
+      [modelService, advanced, select, populate, tasks, basicOptions, advancedOptions, requestConfig, mountRef]
+    );
+    const { isPending, error, executeMutate, reset: resetError } = useMutation(execute, { onSuccess, onSettled });
+    const mutate = (0, import_react2.useCallback)(
+      async (updateId, updateData) => {
+        try {
+          return await executeMutate(updateId, updateData);
+        } catch (err) {
+          onError?.(err);
+          throw err;
+        }
+      },
+      [executeMutate, onError]
+    );
+    const reset = (0, import_react2.useCallback)(() => {
+      setData(null);
+      resetError();
+    }, [resetError]);
+    return { data, isPending, error, mutate, reset };
+  }
+  function useUpsert(options = {}) {
+    const {
+      advanced,
+      select,
+      populate,
+      tasks,
+      basicOptions,
+      advancedOptions,
+      requestConfig,
+      onSuccess,
+      onError,
+      onSettled
+    } = options;
+    const [data, setData] = (0, import_react2.useState)(null);
+    const mountRef = useMountRef();
+    const execute = (0, import_react2.useCallback)(
+      async (upsertData) => {
+        let res;
+        if (advanced) {
+          res = await modelService.upsertAdvanced(
+            upsertData,
+            { select, populate, tasks },
+            advancedOptions,
+            requestConfig
+          ).exec();
+        } else {
+          res = await modelService.upsert(upsertData, basicOptions, requestConfig).exec();
+        }
+        if (mountRef.current) setData(res.data);
+        return res;
+      },
+      [modelService, advanced, select, populate, tasks, basicOptions, advancedOptions, requestConfig, mountRef]
+    );
+    const { isPending, error, executeMutate, reset: resetError } = useMutation(execute, { onSuccess, onSettled });
+    const mutate = (0, import_react2.useCallback)(
+      async (upsertData) => {
+        try {
+          return await executeMutate(upsertData);
+        } catch (err) {
+          onError?.(err);
+          throw err;
+        }
+      },
+      [executeMutate, onError]
+    );
+    const reset = (0, import_react2.useCallback)(() => {
+      setData(null);
+      resetError();
+    }, [resetError]);
+    return { data, isPending, error, mutate, reset };
+  }
+  function useDelete(options = {}) {
+    const { requestConfig, onSuccess, onError, onSettled } = options;
+    const execute = (0, import_react2.useCallback)(
+      async (deleteId) => {
+        const res = await modelService.delete(deleteId, requestConfig).exec();
+        return res;
+      },
+      [modelService, requestConfig]
+    );
+    const { isPending, error, executeMutate, reset } = useMutation(execute, { onSuccess, onSettled });
+    const mutate = (0, import_react2.useCallback)(
+      async (deleteId) => {
+        try {
+          return await executeMutate(deleteId);
+        } catch (err) {
+          onError?.(err);
+          throw err;
+        }
+      },
+      [executeMutate, onError]
+    );
+    return { isPending, error, mutate, reset };
+  }
+  function useCount(options = {}) {
+    const { advanced, filter, enabled = true, requestConfig, onSuccess, onError, onSettled } = options;
+    const [data, setData] = (0, import_react2.useState)(null);
+    const applyResult = (0, import_react2.useCallback)((res) => {
+      setData(res.data);
+    }, []);
+    const doFetch = (0, import_react2.useCallback)(
+      async (signal) => {
+        if (advanced) {
+          return await modelService.countAdvanced(filter ?? {}, void 0, { ...requestConfig, signal }).exec();
+        }
+        return await modelService.count({ ...requestConfig, signal }).exec();
+      },
+      [modelService, advanced, filter, requestConfig]
+    );
+    const filterKey = stableStringify(filter);
+    const { isLoading, error, refetch } = useAutoQuery({
+      doFetch,
+      applyResult,
+      shouldFetch: enabled,
+      deps: [enabled, advanced, filterKey],
+      onSuccess,
+      onError,
+      onSettled
+    });
+    const query = (0, import_react2.useCallback)(async () => {
+      const res = await doFetch();
+      applyResult(res);
+      onSuccess?.(res);
+      onSettled?.(res, null);
+      return res;
+    }, [doFetch, applyResult, onSuccess, onSettled]);
+    const reset = (0, import_react2.useCallback)(() => {
+      setData(null);
+    }, []);
+    return { data, isLoading, error, query, refetch, reset };
+  }
+  function useDistinct(options) {
+    const { field, conditions, enabled = true, requestConfig, onSuccess, onError, onSettled } = options;
+    const [data, setData] = (0, import_react2.useState)(null);
+    const applyResult = (0, import_react2.useCallback)((res) => {
+      setData(res.data);
+    }, []);
+    const doFetch = (0, import_react2.useCallback)(
+      async (signal) => {
+        if (conditions && Object.keys(conditions).length > 0) {
+          return await modelService.distinctAdvanced(field, conditions, { ...requestConfig, signal }).exec();
+        }
+        return await modelService.distinct(field, { ...requestConfig, signal }).exec();
+      },
+      [modelService, field, conditions, requestConfig]
+    );
+    const conditionsKey = stableStringify(conditions);
+    const { isLoading, error, refetch } = useAutoQuery({
+      doFetch,
+      applyResult,
+      shouldFetch: enabled,
+      deps: [enabled, field, conditionsKey],
+      onSuccess,
+      onError,
+      onSettled
+    });
+    const query = (0, import_react2.useCallback)(async () => {
+      const res = await doFetch();
+      applyResult(res);
+      onSuccess?.(res);
+      onSettled?.(res, null);
+      return res;
+    }, [doFetch, applyResult, onSuccess, onSettled]);
+    const reset = (0, import_react2.useCallback)(() => {
+      setData(null);
+    }, []);
+    return { data, isLoading, error, query, refetch, reset };
+  }
+  return {
+    useRead,
+    useList,
+    useCreate,
+    useUpdate,
+    useUpsert,
+    useDelete,
+    useCount,
+    useDistinct
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createModelHooks
+});