@vef-framework/core 1.0.122 → 1.0.124

package/cjs/index.cjs

@@ -0,0 +1,24 @@
+"use strict";
+'use strict';
+
+require('./api/index.cjs');
+require('./auth/index.cjs');
+var compiler = require('./expr/compiler.cjs');
+var apiClient = require('./api/api-client.cjs');
+var reactQuery = require('@tanstack/react-query');
+var apiContext = require('./api/api-context.cjs');
+var authContext = require('./auth/auth-context.cjs');
+
+"use strict";
+
+exports.compile = compiler.compile;
+exports.ApiClient = apiClient.ApiClient;
+exports.createApiClient = apiClient.createApiClient;
+Object.defineProperty(exports, "useQueryErrorResetBoundary", {
+	enumerable: true,
+	get: function () { return reactQuery.useQueryErrorResetBoundary; }
+});
+exports.ApiContextProvider = apiContext.ApiContextProvider;
+exports.useApiContext = apiContext.useApiContext;
+exports.AuthContextProvider = authContext.AuthContextProvider;
+exports.useAuthContext = authContext.useAuthContext;

package/cjs/middleware/dispatcher.cjs

@@ -0,0 +1,33 @@
+"use strict";
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+"use strict";
+function createDispatcher() {
+  const middlewares = [];
+  let currentIndex = 0;
+  const dispatcher = (middleware) => middlewares.push(middleware);
+  const dispatch = (payload) => {
+    const current = middlewares[currentIndex];
+    if (typeof current === "function") {
+      return current(payload, (explicitPayload) => {
+        currentIndex++;
+        return dispatch(explicitPayload);
+      });
+    }
+    currentIndex = 0;
+    return payload;
+  };
+  dispatcher.dispatch = dispatch;
+  dispatcher.unshift = (middleware) => middlewares.unshift(middleware);
+  dispatcher.remove = (middleware) => {
+    const index = middlewares.indexOf(middleware);
+    if (index > -1) {
+      middlewares.splice(index, 1);
+    }
+  };
+  return dispatcher;
+}
+
+exports.default = createDispatcher;

package/esm/api/api-client.js

@@ -0,0 +1,544 @@
+"use strict";
+import { useQuery, keepPreviousData, useSuspenseQuery, useMutation, useIsFetching, useIsMutating, QueryClientProvider } from '@tanstack/react-query';
+import { createElement } from 'react';
+import { createQueryClient } from './query-client.js';
+import { createRequestClient } from './request-client.js';
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _queryClient, _requestClient, _requestMethods, _currentSignal, _ApiClient_instances, selectData_fn, wrapRefetchFn_fn, createQueryResult_fn, createApi_fn;
+class ApiClient {
+  /**
+   * Create an API client.
+   *
+   * @param options - The options of the API client.
+   */
+  constructor(options) {
+    this.options = options;
+    __privateAdd(this, _ApiClient_instances);
+    /**
+     * The useApiQuery hook.
+     * These hook functions are doing this because React's Hooks cannot be used in class methods,
+     * and this approach can bypass the check.
+     */
+    __publicField(this, "useApiQuery");
+    /**
+     * The useSuspenseApiQuery hook.
+     */
+    __publicField(this, "useSuspenseApiQuery");
+    /**
+     * The useApiMutation hook.
+     * These hook functions are doing this because React's Hooks cannot be used in class methods,
+     * and this approach can bypass the check.
+     */
+    __publicField(this, "useApiMutation");
+    /**
+     * The useIsFetching hook.
+     */
+    __publicField(this, "useIsFetching");
+    /**
+     * The useIsMutating hook.
+     */
+    __publicField(this, "useIsMutating");
+    /**
+     * THe QueryClientProvider component.
+     */
+    __publicField(this, "QueryClientProvider");
+    /**
+     * The query client.
+     */
+    __privateAdd(this, _queryClient);
+    /**
+     * The request client.
+     */
+    __privateAdd(this, _requestClient);
+    /**
+     * The request methods.
+     */
+    __privateAdd(this, _requestMethods);
+    /**
+     * The current signal.
+     */
+    __privateAdd(this, _currentSignal);
+    __privateSet(this, _queryClient, createQueryClient(options));
+    __privateSet(this, _requestClient, createRequestClient(options));
+    __privateSet(this, _requestMethods, {
+      get: async (url, options2) => {
+        const signal = __privateGet(this, _currentSignal);
+        __privateSet(this, _currentSignal, void 0);
+        return await __privateGet(this, _requestClient).get(url, {
+          ...options2,
+          signal
+        });
+      },
+      post: async (url, data, options2) => {
+        const signal = __privateGet(this, _currentSignal);
+        __privateSet(this, _currentSignal, void 0);
+        return await __privateGet(this, _requestClient).post(url, data, {
+          ...options2,
+          signal
+        });
+      },
+      put: async (url, data, options2) => {
+        const signal = __privateGet(this, _currentSignal);
+        __privateSet(this, _currentSignal, void 0);
+        return await __privateGet(this, _requestClient).put(url, data, {
+          ...options2,
+          signal
+        });
+      },
+      delete: async (url, options2) => {
+        const signal = __privateGet(this, _currentSignal);
+        __privateSet(this, _currentSignal, void 0);
+        return await __privateGet(this, _requestClient).delete(url, {
+          ...options2,
+          signal
+        });
+      }
+    });
+    const that = this;
+    this.useApiQuery = function useApiQuery(queryFn, args, options2) {
+      var _a;
+      const {
+        keepPreviousData: keepPreviousData$1,
+        placeholderData,
+        initialData,
+        ...restOptions
+      } = options2 ?? {};
+      const result = useQuery({
+        queryKey: [queryFn.key, args],
+        queryFn: ({ signal }) => queryFn(args, { signal }),
+        select: __privateMethod(that, _ApiClient_instances, selectData_fn),
+        placeholderData: placeholderData ?? keepPreviousData$1 === true ? keepPreviousData : void 0,
+        initialData: initialData ? {
+          code: 0,
+          message: "ok",
+          data: initialData
+        } : void 0,
+        ...restOptions
+      });
+      return __privateMethod(_a = that, _ApiClient_instances, createQueryResult_fn).call(_a, result);
+    };
+    this.useSuspenseApiQuery = function useSuspenseApiQuery(queryFn, args, options2) {
+      const {
+        keepPreviousData,
+        initialData,
+        ...restOptions
+      } = options2 ?? {};
+      const { data, refetch } = useSuspenseQuery({
+        queryKey: [queryFn.key, args],
+        queryFn: ({ signal }) => queryFn(args, { signal }),
+        select: __privateMethod(that, _ApiClient_instances, selectData_fn),
+        initialData: initialData ? {
+          code: 0,
+          message: "ok",
+          data: initialData
+        } : void 0,
+        ...restOptions
+      });
+      return {
+        data,
+        refetch: __privateMethod(this, _ApiClient_instances, wrapRefetchFn_fn).call(this, refetch)
+      };
+    };
+    this.useApiMutation = function useApiMutation(mutationFn) {
+      const {
+        isPending,
+        isIdle,
+        isError,
+        isSuccess,
+        error,
+        data,
+        mutateAsync
+      } = useMutation({
+        mutationKey: [mutationFn.key],
+        mutationFn: (args) => mutationFn(args)
+      });
+      const mutate = async (args) => await mutateAsync(args);
+      return {
+        mutate,
+        isPending,
+        isIdle,
+        isError,
+        isSuccess,
+        message: data?.message,
+        error: error ?? void 0,
+        data: data?.data
+      };
+    };
+    this.useIsFetching = function useIsFetching$1(apiKey, args) {
+      const count = useIsFetching({
+        queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+        type: "active",
+        exact: false
+      });
+      return count > 0;
+    };
+    this.useIsMutating = function useIsMutating$1(apiKey) {
+      const count = useIsMutating({
+        mutationKey: [apiKey],
+        exact: false
+      });
+      return count > 0;
+    };
+    this.QueryClientProvider = function QueryClientProvider$1({ children }) {
+      return createElement(
+        QueryClientProvider,
+        {
+          client: __privateGet(that, _queryClient)
+        },
+        children
+      );
+    };
+  }
+  /**
+   * Fetch the API query.
+   *
+   * @param queryFn - The API function.
+   * @param args - The arguments of the API.
+   * @param options - The options of the API.
+   * @returns The API query.
+   */
+  async fetchApiQuery(queryFn, args, options) {
+    const { initialData, ...restOptions } = options ?? {};
+    const result = await __privateGet(this, _queryClient).fetchQuery({
+      queryKey: [queryFn.key, args],
+      queryFn: ({ signal }) => queryFn(args, { signal }),
+      initialData: initialData ? {
+        code: 0,
+        message: "ok",
+        data: initialData
+      } : void 0,
+      ...restOptions
+    });
+    return result.data;
+  }
+  /**
+   * Create a query API.
+   *
+   * @param key - The key of the API.
+   * @param factory - The factory of the API function.
+   * @returns The query API.
+   */
+  createQueryApi(key, factory) {
+    const apiFn = __privateMethod(this, _ApiClient_instances, createApi_fn).call(this, key, factory);
+    apiFn.useQuery = this.useApiQuery.bind(this, apiFn);
+    apiFn.useSuspenseQuery = this.useSuspenseApiQuery.bind(this, apiFn);
+    apiFn.fetchQuery = this.fetchApiQuery.bind(this, apiFn);
+    apiFn.getQueryData = this.getApiQueryData.bind(this, key);
+    apiFn.getQueriesData = this.getApiQueriesData.bind(this, key);
+    apiFn.setQueryData = (data, args) => this.setApiQueryData(data, key, args);
+    apiFn.ensureQueryData = this.ensureApiQueryData.bind(this, apiFn);
+    apiFn.removeQueries = this.removeApiQueries.bind(this, key);
+    apiFn.invalidateQueries = this.invalidateApiQueries.bind(this, key);
+    apiFn.resetQueries = this.resetApiQueries.bind(this, key);
+    apiFn.refetchQueries = this.refetchApiQueries.bind(this, key);
+    apiFn.cancelQueries = this.cancelApiQueries.bind(this, key);
+    apiFn.isFetching = this.isFetching.bind(this, key);
+    apiFn.useIsFetching = this.useIsFetching.bind(void 0, key);
+    return Object.freeze(apiFn);
+  }
+  /**
+   * Create a mutation API.
+   *
+   * @param key - The key of the API.
+   * @param factory - The factory of the API function.
+   * @param relatedQueries - The related queries.
+   * @returns The mutation API.
+   */
+  createMutationApi(key, factory, relatedQueries = []) {
+    const apiFn = __privateMethod(this, _ApiClient_instances, createApi_fn).call(this, key, factory);
+    apiFn.relatedQueries = Object.freeze(relatedQueries);
+    apiFn.useMutation = this.useApiMutation.bind(this, apiFn);
+    apiFn.refetchRelatedQueries = function refetchRelatedQueries() {
+      return Promise.all(
+        relatedQueries.map((query) => query.refetchQueries())
+      );
+    };
+    apiFn.invalidateRelatedQueries = function invalidateRelatedQueries() {
+      return Promise.all(
+        relatedQueries.map((query) => query.invalidateQueries())
+      );
+    };
+    apiFn.isMutating = this.isMutating.bind(this, key);
+    apiFn.useIsMutating = this.useIsMutating.bind(void 0, key);
+    return Object.freeze(apiFn);
+  }
+  /**
+   * Get the API query data.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   * @returns The API query data.
+   */
+  getApiQueryData(apiKey, args) {
+    return __privateGet(this, _queryClient).getQueryData(
+      arguments.length > 1 ? [apiKey, args] : [apiKey]
+    );
+  }
+  /**
+   * Get the API queries data.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   * @returns The API queries data.
+   */
+  getApiQueriesData(apiKey, args) {
+    return __privateGet(this, _queryClient).getQueriesData({
+      queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+      type: "active",
+      exact: false
+    });
+  }
+  /**
+   * Set the API query data.
+   *
+   * @param data - The data.
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  setApiQueryData(data, apiKey, args) {
+    __privateGet(this, _queryClient).setQueryData(
+      arguments.length > 2 ? [apiKey, args] : [apiKey],
+      data
+    );
+  }
+  /**
+   * Ensure the API query data.
+   *
+   * @param queryFn - The API function.
+   * @param args - The arguments of the API.
+   * @param options - The options of the API.
+   * @returns The API query data.
+   */
+  async ensureApiQueryData(queryFn, args, options) {
+    const { initialData, ...restOptions } = options ?? {};
+    const result = await __privateGet(this, _queryClient).ensureQueryData({
+      queryKey: [queryFn.key, args],
+      queryFn: ({ signal }) => queryFn(args, { signal }),
+      initialData: initialData ? {
+        code: 0,
+        message: "ok",
+        data: initialData
+      } : void 0,
+      ...restOptions,
+      revalidateIfStale: true
+    });
+    return result.data;
+  }
+  /**
+   * Remove the API queries.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  removeApiQueries(apiKey, args) {
+    __privateGet(this, _queryClient).removeQueries({
+      type: "all",
+      exact: false,
+      queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey]
+    });
+  }
+  /**
+   * Invalidate the API queries.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  invalidateApiQueries(apiKey, args) {
+    return __privateGet(this, _queryClient).invalidateQueries(
+      {
+        queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+        type: "all",
+        exact: false,
+        stale: false,
+        refetchType: "active"
+      },
+      {
+        throwOnError: false,
+        cancelRefetch: false
+      }
+    );
+  }
+  /**
+   * Reset the API queries.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  resetApiQueries(apiKey, args) {
+    return __privateGet(this, _queryClient).resetQueries(
+      {
+        queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+        type: "active",
+        exact: false
+      },
+      {
+        cancelRefetch: true,
+        throwOnError: false
+      }
+    );
+  }
+  /**
+   * Refetch the API queries.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  refetchApiQueries(apiKey, args) {
+    return __privateGet(this, _queryClient).refetchQueries(
+      {
+        queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+        type: "active",
+        exact: false
+      },
+      {
+        throwOnError: false,
+        cancelRefetch: false
+      }
+    );
+  }
+  /**
+   * Cancel the API queries.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   */
+  cancelApiQueries(apiKey, args) {
+    return __privateGet(this, _queryClient).cancelQueries(
+      {
+        queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+        type: "active",
+        exact: false
+      },
+      {
+        revert: true,
+        silent: true
+      }
+    );
+  }
+  /**
+   * Check if the API query/queries is fetching.
+   *
+   * @param apiKey - The key of the API.
+   * @param args - The arguments of the API.
+   * @returns Whether the API query is fetching.
+   */
+  isFetching(apiKey, args) {
+    return __privateGet(this, _queryClient).isFetching({
+      queryKey: arguments.length > 1 ? [apiKey, args] : [apiKey],
+      type: "active",
+      exact: false
+    }) > 0;
+  }
+  /**
+   * Check if the API mutation is mutating.
+   *
+   * @param apiKey - The key of the API.
+   * @returns Whether the API mutation is mutating.
+   */
+  isMutating(apiKey) {
+    return __privateGet(this, _queryClient).isMutating({
+      mutationKey: [apiKey],
+      exact: false
+    }) > 0;
+  }
+}
+_queryClient = new WeakMap();
+_requestClient = new WeakMap();
+_requestMethods = new WeakMap();
+_currentSignal = new WeakMap();
+_ApiClient_instances = new WeakSet();
+/**
+ * Select the data.
+ *
+ * @param data - The data.
+ * @returns The data.
+ */
+selectData_fn = function(data) {
+  return data.data;
+};
+/**
+ * Wrap the refetch function.
+ *
+ * @param refetch - The refetch function.
+ * @returns The refetch result.
+ */
+wrapRefetchFn_fn = function(refetch) {
+  return async (options) => {
+    const result = await refetch(options);
+    return {
+      isSuccess: result.isSuccess,
+      isError: result.isError,
+      error: result.error,
+      data: result.data
+    };
+  };
+};
+/**
+ * Create a query result.
+ *
+ * @returns The query result.
+ */
+createQueryResult_fn = function({
+  isPending,
+  isFetching,
+  isLoading,
+  isRefetching,
+  isSuccess,
+  isPlaceholderData,
+  isError,
+  isLoadingError,
+  isRefetchError,
+  isStale,
+  error,
+  data,
+  refetch
+}) {
+  return {
+    isPending,
+    isSuccess,
+    isError,
+    isLoadingError,
+    isRefetchError,
+    isLoading,
+    isFetching,
+    isRefetching,
+    isPlaceholderData,
+    isStale,
+    error: error ?? void 0,
+    data,
+    refetch: __privateMethod(this, _ApiClient_instances, wrapRefetchFn_fn).call(this, refetch)
+  };
+};
+/**
+ * Create an API.
+ *
+ * @param key - The key of the API.
+ * @param factory - The factory of the API function.
+ * @returns The API.
+ */
+createApi_fn = function(key, factory) {
+  const fn = factory(__privateGet(this, _requestMethods));
+  const apiFn = async (args, apiOptions) => {
+    __privateSet(this, _currentSignal, apiOptions?.signal);
+    return await fn(args);
+  };
+  apiFn.key = key;
+  return apiFn;
+};
+function createApiClient(options) {
+  return Object.freeze(new ApiClient(options));
+}
+
+export { ApiClient, createApiClient };

package/esm/api/api-context.js

@@ -0,0 +1,95 @@
+"use strict";
+import { VefError } from '@vef-framework/shared';
+import { createContext, useMemo, createElement, useContext } from 'react';
+
+"use strict";
+const Context = createContext(null);
+const ApiContextProvider = ({
+  client,
+  dataDictionaryApi,
+  loginApi,
+  logoutApi,
+  fetchAuthenticatedUserApi,
+  children
+}) => {
+  const apiContext = useMemo(() => {
+    const stubQueryApi = client.createQueryApi(
+      "_vefStubQueryApi",
+      () => (stubData) => Promise.resolve({
+        code: 0,
+        message: "ok",
+        data: stubData
+      })
+    );
+    const asyncFnQueryApi = client.createQueryApi(
+      "_vefAsyncFnQueryApi",
+      () => async ({ args, fn }) => ({
+        code: 0,
+        message: "ok",
+        data: await fn(...args)
+      })
+    );
+    const stubMutationApi = client.createMutationApi(
+      "_vefStubMutationApi",
+      () => (stubData) => Promise.resolve({
+        code: 0,
+        message: "ok",
+        data: stubData
+      })
+    );
+    const asyncFnMutationApi = client.createMutationApi(
+      "_vefAsyncFnMutationApi",
+      () => async ({ args, fn }) => ({
+        code: 0,
+        message: "ok",
+        data: await fn(...args)
+      })
+    );
+    return Object.freeze({
+      useApiQuery: client.useApiQuery,
+      useSuspenseApiQuery: client.useSuspenseApiQuery,
+      useApiMutation: client.useApiMutation,
+      useIsFetching: client.useIsFetching,
+      useIsMutating: client.useIsMutating,
+      fetchApiQuery: client.fetchApiQuery.bind(client),
+      createQueryApi: client.createQueryApi.bind(client),
+      createMutationApi: client.createMutationApi.bind(client),
+      getApiQueryData: client.getApiQueryData.bind(client),
+      getApiQueriesData: client.getApiQueriesData.bind(client),
+      setApiQueryData: client.setApiQueryData.bind(client),
+      ensureApiQueryData: client.ensureApiQueryData.bind(client),
+      removeApiQueries: client.removeApiQueries.bind(client),
+      invalidateApiQueries: client.invalidateApiQueries.bind(client),
+      resetApiQueries: client.resetApiQueries.bind(client),
+      refetchApiQueries: client.refetchApiQueries.bind(client),
+      cancelApiQueries: client.cancelApiQueries.bind(client),
+      isFetching: client.isFetching.bind(client),
+      isMutating: client.isMutating.bind(client),
+      stubQueryApi,
+      asyncFnQueryApi,
+      stubMutationApi,
+      asyncFnMutationApi,
+      dataDictionaryApi,
+      loginApi,
+      logoutApi,
+      fetchAuthenticatedUserApi
+    });
+  }, [client, dataDictionaryApi, loginApi, logoutApi, fetchAuthenticatedUserApi]);
+  return createElement(
+    Context.Provider,
+    { value: apiContext },
+    createElement(client.QueryClientProvider, {}, children)
+  );
+};
+function useApiContext() {
+  const context = useContext(Context);
+  if (context === null) {
+    throw new VefError(
+      -1,
+      "Api context not found: Please ensure useApiContext is called within an ApiContextProvider"
+    );
+  }
+  return context;
+}
+
+export { ApiContextProvider, useApiContext };

package/esm/api/index.js

@@ -0,0 +1,6 @@
+"use strict";
+export { ApiClient, createApiClient } from './api-client.js';
+export { ApiContextProvider, useApiContext } from './api-context.js';
+export { useQueryErrorResetBoundary } from '@tanstack/react-query';
+
+"use strict";