@plasmicapp/data-sources 0.1.171 → 0.1.173

package/dist/index.d.ts

@@ -8,6 +8,39 @@ export declare type BaseFieldConfig = {
     fieldId?: string;
 };
 
+/**
+ * Represents the result of a client-side query.
+ */
+export declare interface ClientQueryResult<T = any> {
+    /**
+     * The data returned by the query. May be undefined if the query has not yet completed.
+     */
+    data?: T;
+    /**
+     * The schema of the table from which the data was queried. Only available for plasmic data
+     * integration. May be undefined if the query has not yet completed.
+     */
+    schema?: TableSchema;
+    /**
+     * The total number of records available. Only available for plasmic data integration. May be
+     * undefined if the query has not yet completed.
+     */
+    total?: number;
+    /**
+     * Pagination information for the query result. Only available for plasmic data integration. May be
+     * undefined if the query has not yet completed.
+     */
+    paginate?: Pagination;
+    /**
+     * Any error that occurred during the query. This is optional and may be undefined.
+     */
+    error?: any;
+    /**
+     * Indicates whether the query is currently loading.
+     */
+    isLoading?: boolean;
+}
+
 export declare interface DataOp {
     sourceId: string;
     opId: string;
@@ -50,7 +83,7 @@ export declare function executePlasmicDataOp<T extends SingleRowResult | ManyRow
  * Executes a server query, returning either the result of the query or a
  * PlasmicUndefinedServerProxy if the query depends on data that is not yet ready
  */
-export declare function executeServerQuery<F extends (...args: any[]) => any>(serverQuery: ServerQuery<F>): Promise<ServerQueryResult<ReturnType<F>> | ServerQueryResult<{}>>;
+export declare function executeServerQuery<F extends (...args: any[]) => any>(serverQuery: ServerQuery<F>): Promise<ServerQueryResult<ReturnType<F> | {}>>;
 
 export declare function Fetcher(props: FetcherProps): React_2.ReactElement | null;
 
@@ -67,6 +100,8 @@ export declare function makeCacheKey(dataOp: DataOp, opts?: {
     userAuthToken?: string | null;
 }): string;
 
+export declare function makeQueryCacheKey(id: string, params: any[]): string;
+
 export declare interface ManyRowsResult<T = any> {
     data: T[];
     total?: number;
@@ -98,9 +133,10 @@ export declare type QueryResult = Partial<ManyRowsResult<any>> & {
 
 declare type ResolvableDataOp = DataOp | undefined | null | (() => DataOp | undefined | null);
 
-export declare interface ServerQuery<F extends (...args: any[]) => any> {
+export declare interface ServerQuery<F extends (...args: any[]) => Promise<any>> {
     fn: F;
     execParams: () => Parameters<F>;
+    id: string;
 }
 
 export declare interface ServerQueryResult<T = any> {
@@ -145,14 +181,15 @@ export declare function usePlasmicDataMutationOp<T extends SingleRowResult | Man
 export declare function usePlasmicDataOp<T extends SingleRowResult | ManyRowsResult, E = any>(dataOp: ResolvableDataOp, opts?: {
     paginate?: Pagination;
     noUndefinedDataProxy?: boolean;
-}): Partial<T> & {
-    error?: E;
-    isLoading?: boolean;
-};
+}): ClientQueryResult<T["data"]>;
 
 /**
  * Returns a function that can be used to invalidate Plasmic query groups.
  */
 export declare function usePlasmicInvalidate(): (invalidatedKeys: string[] | null | undefined) => Promise<any[] | undefined>;
 
+export declare function usePlasmicServerQuery<F extends (...args: any[]) => Promise<any>>(serverQuery: ServerQuery<F>, fallbackData?: ReturnType<F>, opts?: {
+    noUndefinedDataProxy?: boolean;
+}): Partial<ServerQueryResult<ReturnType<F>>>;
+
 export { }

package/dist/index.esm.js

@@ -39,19 +39,188 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/index.tsx
-import { usePlasmicDataConfig as usePlasmicDataConfig2 } from "@plasmicapp/query";
+import { usePlasmicDataConfig as usePlasmicDataConfig3 } from "@plasmicapp/query";
 
 // src/components/Fetcher.tsx
-import React2 from "react";
+import React3 from "react";
 
 // src/hooks/usePlasmicDataOp.tsx
 import { usePlasmicDataSourceContext } from "@plasmicapp/data-sources-context";
-import * as ph from "@plasmicapp/host";
+import {
+  usePlasmicDataConfig as usePlasmicDataConfig2
+} from "@plasmicapp/query";
+import * as React2 from "react";
+
+// src/common.ts
 import {
   useMutablePlasmicQueryData,
   usePlasmicDataConfig
 } from "@plasmicapp/query";
-import * as React from "react";
+import * as ph from "@plasmicapp/host";
+import React from "react";
+function isPlasmicUndefinedDataErrorPromise(x) {
+  return !!x && typeof x === "object" && (x == null ? void 0 : x.plasmicType) === "PlasmicUndefinedDataError";
+}
+function mkUndefinedDataProxy(promiseRef, fetchAndUpdateCache) {
+  let fetchAndUpdatePromise = void 0;
+  return new Proxy(
+    {},
+    {
+      get: (_target, prop) => {
+        if (prop === "isPlasmicUndefinedDataProxy") {
+          return true;
+        }
+        if (!fetchAndUpdateCache) {
+          return void 0;
+        }
+        const doFetchAndUpdate = () => {
+          if (!fetchAndUpdatePromise) {
+            fetchAndUpdatePromise = fetchAndUpdateCache().finally(() => {
+              fetchAndUpdatePromise = void 0;
+            });
+          }
+          return fetchAndUpdatePromise;
+        };
+        const promise = (
+          // existing fetch
+          promiseRef.fetchingPromise || // No existing fetch, so kick off a fetch
+          doFetchAndUpdate()
+        );
+        promise.plasmicType = "PlasmicUndefinedDataError";
+        promise.message = `Cannot read property ${String(
+          prop
+        )} - data is still loading`;
+        throw promise;
+      }
+    }
+  );
+}
+var isRSC = React.isRSC;
+var reactMajorVersion = +React.version.split(".")[0];
+var enableLoadingBoundaryKey = "plasmicInternalEnableLoadingBoundary";
+var PRE_FETCHES = /* @__PURE__ */ new Map();
+function usePlasmicFetch(key, resolvedParams, fetcherFn, resultMapper, undefinedDataProxyFields, opts) {
+  var _a, _b;
+  const enableLoadingBoundary = !!((_b = (_a = ph.useDataEnv) == null ? void 0 : _a()) == null ? void 0 : _b[enableLoadingBoundaryKey]);
+  const { mutate, cache } = isRSC ? {} : usePlasmicDataConfig();
+  const isNullParams = !resolvedParams;
+  const isWaitingOnDependentQuery = isPlasmicUndefinedDataErrorPromise(resolvedParams);
+  const fetchingData = React.useMemo(
+    () => ({
+      fetchingPromise: void 0
+    }),
+    [key]
+  );
+  const fetcher = React.useMemo(
+    () => () => {
+      if (!key) {
+        throw new Error(`Fetcher should never be called without a proper key`);
+      }
+      if (fetchingData.fetchingPromise) {
+        return fetchingData.fetchingPromise;
+      }
+      if (key && PRE_FETCHES.has(key)) {
+        const existing = PRE_FETCHES.get(key);
+        fetchingData.fetchingPromise = existing;
+        return existing;
+      }
+      const fetcherPromise = fetcherFn(resolvedParams);
+      fetchingData.fetchingPromise = fetcherPromise;
+      if (key) {
+        PRE_FETCHES.set(key, fetcherPromise);
+        fetcherPromise.then(
+          () => {
+            PRE_FETCHES.delete(key);
+          },
+          () => {
+            PRE_FETCHES.delete(key);
+          }
+        );
+      }
+      return fetcherPromise;
+    },
+    [key, fetchingData]
+  );
+  const dependentKeyDataErrorPromise = isPlasmicUndefinedDataErrorPromise(
+    resolvedParams
+  ) ? resolvedParams : void 0;
+  const fetchAndUpdateCache = React.useMemo(() => {
+    if (!key && !dependentKeyDataErrorPromise) {
+      return void 0;
+    }
+    return () => {
+      if (fetchingData.fetchingPromise) {
+        return fetchingData.fetchingPromise;
+      }
+      if (dependentKeyDataErrorPromise) {
+        return dependentKeyDataErrorPromise;
+      }
+      if (!key) {
+        throw new Error(`Expected key to be non-null`);
+      }
+      const cached = cache == null ? void 0 : cache.get(key);
+      if (cached) {
+        return Promise.resolve(cached);
+      }
+      const cachedError = cache == null ? void 0 : cache.get(`$swr$${key}`);
+      if (cachedError) {
+        return Promise.reject(cachedError.error);
+      }
+      const fetcherPromise = new Promise((resolve, reject) => {
+        setTimeout(() => {
+          fetcher().then(resolve, reject);
+        }, 1);
+      });
+      if (!isRSC) {
+        fetcherPromise.then((data2) => {
+          mutate == null ? void 0 : mutate(key, data2);
+        }).catch((err) => {
+          var _a2;
+          const keyInfo = key ? "$swr$" + key : "";
+          cache == null ? void 0 : cache.set(keyInfo, __spreadProps(__spreadValues({}, (_a2 = cache == null ? void 0 : cache.get(keyInfo)) != null ? _a2 : {}), { error: err }));
+        });
+      }
+      return fetcherPromise;
+    };
+  }, [fetcher, fetchingData, cache, key, dependentKeyDataErrorPromise]);
+  const res = useMutablePlasmicQueryData(key, fetcher, {
+    fallbackData: opts == null ? void 0 : opts.fallbackData,
+    shouldRetryOnError: false,
+    // If revalidateIfStale is true, then if there's a cache entry with a key,
+    // but no mounted hook with that key yet, and when the hook mounts with the key,
+    // swr will revalidate. This may be reasonable behavior, but for us, this
+    // happens all the time -- we prepopulate the cache with proxy-invoked fetch,
+    // sometimes before swr had a chance to run the effect.  So we turn off
+    // revalidateIfStale here, and just let the user manage invalidation.
+    revalidateIfStale: false
+  });
+  const { data, error, isLoading } = res;
+  if (fetchingData.fetchingPromise != null && data !== void 0) {
+    fetchingData.fetchingPromise = void 0;
+  }
+  return React.useMemo(() => {
+    const result = resultMapper(res);
+    if (!(opts == null ? void 0 : opts.noUndefinedDataProxy) && reactMajorVersion >= 18 && enableLoadingBoundary && (isLoading || isNullParams || isWaitingOnDependentQuery) && undefinedDataProxyFields.every((field) => result[field] === void 0)) {
+      undefinedDataProxyFields.forEach((field) => {
+        if (field === "error") {
+          return;
+        }
+        result[field] = mkUndefinedDataProxy(fetchingData, fetchAndUpdateCache);
+      });
+    }
+    return result;
+  }, [
+    isNullParams,
+    isWaitingOnDependentQuery,
+    data,
+    error,
+    isLoading,
+    opts == null ? void 0 : opts.noUndefinedDataProxy,
+    enableLoadingBoundary,
+    fetchingData,
+    fetchAndUpdateCache
+  ]);
+}
 
 // src/executor.tsx
 import fetch from "@plasmicapp/isomorphic-unfetch";
@@ -153,7 +322,6 @@ function withoutNils(xs) {
 }
 
 // src/hooks/usePlasmicDataOp.tsx
-var isRSC2 = React.isRSC;
 function makeCacheKey(dataOp, opts) {
   const queryDependencies = JSON.stringify({
     sourceId: dataOp.sourceId,
@@ -165,7 +333,7 @@ function makeCacheKey(dataOp, opts) {
   return dataOp.cacheKey ? `${dataOp.cacheKey}${queryDependencies}` : queryDependencies;
 }
 function usePlasmicInvalidate() {
-  const { cache, fallback, mutate } = usePlasmicDataConfig();
+  const { cache, fallback, mutate } = usePlasmicDataConfig2();
   return (invalidatedKeys) => __async(this, null, function* () {
     const getKeysToInvalidate = () => {
       var _a, _b;
@@ -214,45 +382,6 @@ function usePlasmicInvalidate() {
     return yield Promise.all(keys.map((key) => invalidateKey(key)));
   });
 }
-var enableLoadingBoundaryKey = "plasmicInternalEnableLoadingBoundary";
-function mkUndefinedDataProxy(promiseRef, fetchAndUpdateCache) {
-  let fetchAndUpdatePromise = void 0;
-  return new Proxy(
-    {},
-    {
-      get: (_target, prop) => {
-        if (prop === "isPlasmicUndefinedDataProxy") {
-          return true;
-        }
-        if (!fetchAndUpdateCache) {
-          return void 0;
-        }
-        const doFetchAndUpdate = () => {
-          if (!fetchAndUpdatePromise) {
-            fetchAndUpdatePromise = fetchAndUpdateCache().finally(() => {
-              fetchAndUpdatePromise = void 0;
-            });
-          }
-          return fetchAndUpdatePromise;
-        };
-        const promise = (
-          // existing fetch
-          promiseRef.fetchingPromise || // No existing fetch, so kick off a fetch
-          doFetchAndUpdate()
-        );
-        promise.plasmicType = "PlasmicUndefinedDataError";
-        promise.message = `Cannot read property ${String(
-          prop
-        )} - data is still loading`;
-        throw promise;
-      }
-    }
-  );
-}
-function isPlasmicUndefinedDataErrorPromise(x) {
-  return !!x && typeof x === "object" && x.plasmicType === "PlasmicUndefinedDataError";
-}
-var reactMajorVersion = +React.version.split(".")[0];
 function resolveDataOp(dataOp) {
   if (typeof dataOp === "function") {
     try {
@@ -267,138 +396,39 @@ function resolveDataOp(dataOp) {
     return dataOp;
   }
 }
-var PRE_FETCHES = /* @__PURE__ */ new Map();
 function usePlasmicDataOp(dataOp, opts) {
-  var _a, _b;
   const resolvedDataOp = resolveDataOp(dataOp);
   const ctx = usePlasmicDataSourceContext();
-  const enableLoadingBoundary = !!((_b = (_a = ph.useDataEnv) == null ? void 0 : _a()) == null ? void 0 : _b[enableLoadingBoundaryKey]);
-  const { mutate, cache } = isRSC2 ? {} : usePlasmicDataConfig();
-  const isNullDataOp = !resolvedDataOp;
-  const isWaitingOnDependentQuery = isPlasmicUndefinedDataErrorPromise(resolvedDataOp);
   const key = !resolvedDataOp || isPlasmicUndefinedDataErrorPromise(resolvedDataOp) ? null : makeCacheKey(resolvedDataOp, {
     paginate: opts == null ? void 0 : opts.paginate,
     userAuthToken: ctx == null ? void 0 : ctx.userAuthToken
   });
-  const fetchingData = React.useMemo(
-    () => ({
-      fetchingPromise: void 0
-    }),
-    [key]
-  );
-  const fetcher = React.useMemo(
-    () => () => {
-      if (!key) {
-        throw new Error(`Fetcher should never be called without a proper key`);
-      }
-      if (fetchingData.fetchingPromise) {
-        return fetchingData.fetchingPromise;
-      }
-      if (key && PRE_FETCHES.has(key)) {
-        const existing = PRE_FETCHES.get(key);
-        fetchingData.fetchingPromise = existing;
-        return existing;
-      }
-      const fetcherFn = () => executePlasmicDataOp(resolvedDataOp, {
-        userAuthToken: (ctx == null ? void 0 : ctx.userAuthToken) || void 0,
-        user: ctx == null ? void 0 : ctx.user,
-        paginate: opts == null ? void 0 : opts.paginate
-      });
-      const fetcherPromise = fetcherFn();
-      fetchingData.fetchingPromise = fetcherPromise;
-      if (key) {
-        PRE_FETCHES.set(key, fetcherPromise);
-        fetcherPromise.then(
-          () => {
-            PRE_FETCHES.delete(key);
-          },
-          () => {
-            PRE_FETCHES.delete(key);
-          }
-        );
-      }
-      return fetcherPromise;
-    },
-    [key, fetchingData]
-  );
-  const dependentKeyDataErrorPromise = isPlasmicUndefinedDataErrorPromise(
-    resolvedDataOp
-  ) ? resolvedDataOp : void 0;
-  const fetchAndUpdateCache = React.useMemo(() => {
-    if (!key && !dependentKeyDataErrorPromise) {
-      return void 0;
-    }
-    return () => {
-      if (fetchingData.fetchingPromise) {
-        return fetchingData.fetchingPromise;
-      }
-      if (dependentKeyDataErrorPromise) {
-        return dependentKeyDataErrorPromise;
-      }
-      if (!key) {
-        throw new Error(`Expected key to be non-null`);
-      }
-      const cached = cache == null ? void 0 : cache.get(key);
-      if (cached) {
-        return Promise.resolve(cached);
-      }
-      const cachedError = cache == null ? void 0 : cache.get(`$swr$${key}`);
-      if (cachedError) {
-        return Promise.reject(cachedError.error);
-      }
-      const fetcherPromise = new Promise((resolve, reject) => {
-        setTimeout(() => {
-          fetcher().then(resolve, reject);
-        }, 1);
-      });
-      if (!isRSC2)
-        fetcherPromise.then((data2) => {
-          mutate == null ? void 0 : mutate(key, data2);
-        }).catch((err) => {
-          var _a2;
-          const keyInfo = key ? "$swr$" + key : "";
-          cache == null ? void 0 : cache.set(keyInfo, __spreadProps(__spreadValues({}, (_a2 = cache == null ? void 0 : cache.get(keyInfo)) != null ? _a2 : {}), { error: err }));
-        });
-      return fetcherPromise;
-    };
-  }, [fetcher, fetchingData, cache, key, dependentKeyDataErrorPromise]);
-  const res = useMutablePlasmicQueryData(key, fetcher, {
-    shouldRetryOnError: false,
-    // If revalidateIfStale is true, then if there's a cache entry with a key,
-    // but no mounted hook with that key yet, and when the hook mounts with the key,
-    // swr will revalidate. This may be reasonable behavior, but for us, this
-    // happens all the time -- we prepopulate the cache with proxy-invoked fetch,
-    // sometimes before swr had a chance to run the effect.  So we turn off
-    // revalidateIfStale here, and just let the user manage invalidation.
-    revalidateIfStale: false
-  });
-  const { data, error, isLoading } = res;
-  if (fetchingData.fetchingPromise != null && data !== void 0) {
-    fetchingData.fetchingPromise = void 0;
-  }
-  return React.useMemo(() => {
-    const result = __spreadValues(__spreadValues({}, data != null ? data : {}), pick(res, "isLoading", "error"));
-    if (!(opts == null ? void 0 : opts.noUndefinedDataProxy) && reactMajorVersion >= 18 && enableLoadingBoundary && (isLoading || isNullDataOp || isWaitingOnDependentQuery) && result.data === void 0 && result.schema === void 0 && result.error === void 0) {
-      result.data = mkUndefinedDataProxy(fetchingData, fetchAndUpdateCache);
-      result.schema = mkUndefinedDataProxy(fetchingData, fetchAndUpdateCache);
+  const fetcher = (op) => {
+    return executePlasmicDataOp(op, {
+      userAuthToken: (ctx == null ? void 0 : ctx.userAuthToken) || void 0,
+      user: ctx == null ? void 0 : ctx.user,
+      paginate: opts == null ? void 0 : opts.paginate
+    });
+  };
+  const resultMapper = (result) => {
+    var _a;
+    return __spreadValues(__spreadValues({}, (_a = result.data) != null ? _a : {}), pick(result, "error", "isLoading"));
+  };
+  return usePlasmicFetch(
+    key,
+    resolvedDataOp,
+    fetcher,
+    resultMapper,
+    ["data", "schema", "error"],
+    {
+      noUndefinedDataProxy: opts == null ? void 0 : opts.noUndefinedDataProxy
     }
-    return result;
-  }, [
-    isNullDataOp,
-    isWaitingOnDependentQuery,
-    data,
-    error,
-    isLoading,
-    opts == null ? void 0 : opts.noUndefinedDataProxy,
-    enableLoadingBoundary,
-    fetchingData,
-    fetchAndUpdateCache
-  ]);
+  );
 }
 function usePlasmicDataMutationOp(dataOp) {
   const ctx = usePlasmicDataSourceContext();
   const userToken = ctx == null ? void 0 : ctx.userAuthToken;
-  const getRealDataOp = React.useCallback(() => __async(this, null, function* () {
+  const getRealDataOp = React2.useCallback(() => __async(this, null, function* () {
     const tryGetRealDataOp = () => __async(this, null, function* () {
       const resolved = resolveDataOp(dataOp);
       if (!resolved) {
@@ -412,7 +442,7 @@ function usePlasmicDataMutationOp(dataOp) {
     });
     return yield tryGetRealDataOp();
   }), [dataOp]);
-  return React.useCallback(() => __async(this, null, function* () {
+  return React2.useCallback(() => __async(this, null, function* () {
     var _a;
     const { sourceId, opId, userArgs } = (_a = yield getRealDataOp()) != null ? _a : {};
     if (!sourceId || !opId) {
@@ -435,7 +465,7 @@ function Fetcher(props) {
   const data = usePlasmicDataOp(dataOp, __spreadValues({}, !!pageIndex && !!pageSize && {
     paginate: { pageIndex, pageSize }
   }));
-  const $queries = React2.useMemo(
+  const $queries = React3.useMemo(
     () => __spreadProps(__spreadValues({}, props.queries), { [name != null ? name : "data"]: data }),
     [props.queries, name, data]
   );
@@ -477,7 +507,7 @@ var FetcherMeta = {
 };
 
 // src/helpers.ts
-import { useMemo as useMemo2 } from "react";
+import { useMemo } from "react";
 function normalizeData(rawData) {
   var _a;
   if (!rawData) {
@@ -494,7 +524,7 @@ function normalizeData(rawData) {
   return { data: dataArray, schema };
 }
 function useNormalizedData(rawData) {
-  return useMemo2(() => normalizeData(rawData), [rawData]);
+  return useMemo(() => normalizeData(rawData), [rawData]);
 }
 function tryGetDataArray(rawData) {
   if (rawData == null || typeof rawData !== "object") {
@@ -588,10 +618,10 @@ function deriveFieldConfigs(specifiedFieldsPartial, schema, makeDefaultConfig) {
 }
 
 // src/hooks/useDependencyAwareQuery.tsx
-import React3 from "react";
+import React4 from "react";
 function usePrevious(value) {
-  const prevValue = React3.useRef(void 0);
-  React3.useEffect(() => {
+  const prevValue = React4.useRef(void 0);
+  React4.useEffect(() => {
     prevValue.current = value;
     return () => {
       prevValue.current = void 0;
@@ -612,7 +642,7 @@ function useDependencyAwareQuery({
   }));
   const finalName = name != null ? name : "data";
   const prevName = usePrevious(finalName);
-  React3.useEffect(() => {
+  React4.useEffect(() => {
     if (!(finalName in $queries) || $queries[finalName] !== data) {
       const $queries2 = __spreadProps(__spreadValues({}, $queries), {
         [finalName]: data
@@ -625,6 +655,50 @@ function useDependencyAwareQuery({
   }, [finalName, prevName, data, $queries, setDollarQueries]);
 }
 
+// src/serverQueries/client.ts
+import {
+  wrapLoadingFetcher as wrapLoadingFetcher2
+} from "@plasmicapp/query";
+
+// src/serverQueries/common.ts
+function resolveParams(params, errorFn) {
+  try {
+    return params();
+  } catch (err) {
+    return errorFn(err);
+  }
+}
+
+// src/serverQueries/client.ts
+function makeQueryCacheKey(id, params) {
+  return `${id}:${JSON.stringify(params)}`;
+}
+function usePlasmicServerQuery(serverQuery, fallbackData, opts) {
+  const resolvedParams = resolveParams(serverQuery.execParams, (err) => {
+    if (isPlasmicUndefinedDataErrorPromise(err)) {
+      return err;
+    }
+    throw err;
+  });
+  const key = !resolvedParams || isPlasmicUndefinedDataErrorPromise(resolvedParams) ? null : makeQueryCacheKey(serverQuery.id, resolvedParams);
+  const fetcher = (params) => {
+    return wrapLoadingFetcher2(serverQuery.fn)(...params);
+  };
+  const resultMapper = (result) => {
+    return __spreadValues({}, pick(result, "data", "error", "isLoading"));
+  };
+  return usePlasmicFetch(
+    key,
+    resolvedParams,
+    fetcher,
+    resultMapper,
+    ["data", "error"],
+    __spreadValues({
+      fallbackData
+    }, opts)
+  );
+}
+
 // src/serverQueries/server.ts
 var PlasmicUndefinedServerError = class extends Error {
   constructor(msg) {
@@ -653,19 +727,14 @@ function mkPlasmicUndefinedServerProxy() {
     isLoading: true
   };
 }
-function resolveParams(params) {
-  try {
-    return params();
-  } catch (err) {
-    if (isPlasmicUndefinedServerError(err)) {
-      return err;
-    }
-    throw err;
-  }
-}
 function executeServerQuery(serverQuery) {
   return __async(this, null, function* () {
-    const resolvedParams = resolveParams(serverQuery.execParams);
+    const resolvedParams = resolveParams(serverQuery.execParams, (err) => {
+      if (isPlasmicUndefinedServerError(err)) {
+        return err;
+      }
+      throw err;
+    });
     if (isPlasmicUndefinedServerError(resolvedParams)) {
       return mkPlasmicUndefinedServerProxy();
     }
@@ -679,13 +748,15 @@ export {
   executePlasmicDataOp,
   executeServerQuery,
   makeCacheKey,
+  makeQueryCacheKey,
   mkPlasmicUndefinedServerProxy,
   normalizeData,
   useDependencyAwareQuery,
   useNormalizedData,
-  usePlasmicDataConfig2 as usePlasmicDataConfig,
+  usePlasmicDataConfig3 as usePlasmicDataConfig,
   usePlasmicDataMutationOp,
   usePlasmicDataOp,
-  usePlasmicInvalidate
+  usePlasmicInvalidate,
+  usePlasmicServerQuery
 };
 //# sourceMappingURL=index.esm.js.map